3. char* konvertieren in std::string

char* konvertieren in std::string

  • N

    Hi zusammen,

    kann mir jemand sagen, wie ich ein

    unsigned char* x = "zz";

    in ein std::string konvertieren kann.

    Habe schon die Suche und Google bemüht, aber es scheint
    mir nicht so einfach zu sein. Muss allerdings dazu sagen,
    dass ich relativ neu in der C++ Welt bin.

    Leider ist der unsigned char* Vorgabe, sonst hätte ich hier direkt
    mit std::string gearbeitet.

    Eine Konvertierung vom std::string in char* habe ich schon hinbekommen,
    eventuell hat hier jemand Verbesserungstipps:

    void obj::set_x(const std::string& x) {

        unsigned char* writable = new unsigned char[x.size() + 1];

        std::copy(x.begin(), x.end(), writable);

        writable[x.size()] = '\0';

    }

    Freue mich auf jede Hilfe!

    Gruß
    Sven

    0
  • E

    Mit dem Konstruktor von std::string .

    EDIT: Der ist übrigens nicht mal explicit also geht es auch implizit.

    EDIT 2:

    //std::string zu C-String
CString = MeinString.c_str();
//oder bei der Definition
const char* CString = MeinString.c_str();

//C-String zu std::string
MeinString = CString;
//oder bei der Definition
std::string MeinString(CString);

    EDIT 3:

    void Funktion(std::string Parameter){...};
Funktion("Hallo"); //Geht, da Konstruktor nicht explicit
    0
  • N

    Danke für deine Antwort.
    Habe mal ein Beispiel vorbereitet, ich beziehe den Inhalt von einem COM Objekt.
    Auf den Constructor von std::string bin ich auch schon gekommen, aber er findet keinen überladenen Constructor der "passt" wenn ich das richtig interpretiere:

    std::string obj::get_x() {

        unsigned char* x = NULL;

        // Wert aus COM Objekt beziehen

        comHandle_->get_x(x);

        // Wert in std::string umwandeln und zurückgeben

        return std::string(x);

    }

    Habe ich hier etwas außer Acht gelassen?
    Die COM-Methode erwartet ein unsigned char*

    0
  • F

    EOutOfResources schrieb:

    ...

    Er möchte einen unsigned char* konvertieren, nicht einen char*.

    0
  • E

    Eigentlich kannst du nur " return x; " schreiben, aber du hast einen [c]unsigned char*[/c]. Wieso hast du keinen Gewöhnlichen? Literale sind auch signed .

    0
  • N

    das COM-Objekt ist leider vorgegeben und erwartet unsigned char*, daher muss ich mit dem unsigned char* arbeiten 😞

    0
  • E

    Ja, das kann man casten. Aber ich weiss nicht genau, wie gut das mit den Vorzeichen geht. Die Stelle habe ich im Standard so auf die Schnelle nicht gefunden.

    0
  • I

    Probiere einfach mal einen Cast auf char*. Ohne Gewähr, jegliche Haftung ist ausgeschlossen, auf deine eigene Verantwortung.
    Oder du guckst, was dir das COM-Objekt genau liefert und wie du daraus am besten das machst, das du benötigst (char*).

    0
  • E

    ipsec schrieb:

    Probiere einfach mal einen Cast auf char*.

    Was wenn es mit seinem Compiler nun funktioniert aber nicht vom Standard abgedeckt wird?

    0
  • Mod

    EOutOfResources schrieb:

    Literale sind auch signed .

    Nein. Sie sind vom Typ Array von const chars. Was ein char genau ist, ist Sache der Implementierung.

    @Threadersteller: Du könntest einen std::basic_string<unsigned char> statt einem std::string benutzen, dann geht alles ganz intuitiv, außer dass du die freien Funktionen die einen std::string brauchen nicht mehr benutzen kannst (unter anderem der Ausgabeoperator). Oder du kannst deinen const unsigned char* in einen const char * umwandeln (mit reinterpret_cast). Dann musst du aber damit rechnen, dass komische Dinge passieren, falls die Zahlen überlaufen.

    0
  • E

    SeppJ schrieb:

    Was ein char genau ist, ist Sache der Implementierung.

    *nachguck* Ok, sorry. Du hast recht ➡ 3.9.1 §1

    0
  • R

    das COM-Objekt ist leider vorgegeben und erwartet unsigned char*, daher muss ich mit dem unsigned char* arbeiten

    unsigned char ist meist nen Indiz drauf, das es keine Zeichenkette ist.
    sondern meist nen Block aus Daten ....

    Stringfunktionen da zu nehmen ist ne schlechte Idee, weil eben das Nullzeichen bei strings eine besondere Bedeutung hat ... und auch einfluss auf das verhalten.

    statt std::string solltest du eher std::vector<unsigned char> in erwaegung Ziehen.

    Noch ein Indiz ist das COM Object. COM sollte niemals Zeichenketten in char Form verarbeiten. Die COM Version einer ZeichenKette ist eine "OLE" Zeichenkette, damit ein BSTR oder max fuer kompatiblitaetsZwecke ein OLECHAR * ....
    Kein COM Object was ich kenne will char * oder unsigend char * als Zeichenketten haben ...

    Ciao ...

    0
  • K

    EOutOfResources schrieb:

    Literale sind auch signed .

    Ok, dann habe ich eine Neuigkeit für Dich:

    Es gibt drei verschiedene "Character-Typen":
    char, signed char, unsigned char

    Anders ausgedrückt:
    is_same<char,signed char>::value liefert false
    is_same<int, signed int >::value liefert true
    😉

    Ob "plain char" vorzeichenbehaftet ist oder nicht, ist nicht festgelegt. Das sollte dich aber auch nicht wirklich interessieren; denn char ist hauptsächlich zum Speichern von Zeichen und weniger für Ganzzahlen da.

    String-Literale sind Lvalue-Ausdrücke, die sich auf const-qualifizierte char-Arrays beziehen, nix mit signed char, auch kein unsigned char.

    Edit: Upps! Du hast ja auch schon nachgeguckt. Ich lasse das trotzdem hier mal so stehen... Ist ja nicht falsch. 😃

    0
Anmelden zum Antworten