Comment faire pour convertir un std::string const char* ou char*?

Comment puis-je convertir un std::string à un char* ou un const char*?

  • Au lieu de: char * writable = new char[str.size() + 1]; Vous pouvez utiliser char inscriptible[str.size() + 1]; Alors vous n'avez pas besoin de s'inquiéter à propos de la suppression écriture ou la gestion des exceptions.
  • Vous ne pouvez pas utiliser str.size (), sauf si la taille est connue à la compilation, il peut aussi débordement de la pile si la taille fixe de la valeur est énorme.
  • char* result = strcpy((char*)malloc(str.length()+1), str.c_str());
  • strcpy et malloc ne sont pas vraiment le C++ façon.
  • vous voulez dire qu'ils sont imaginaires?
  • Non, mais char* dest = new char[str.length() + 1]; std::copy(str.begin(), str.end(), dest) serait plus idiomatiques C++. strcpy() et malloc() ne sont pas mauvais ou problématiques, mais il semble incohérent d'utiliser une chaîne C++ et C installations de la bibliothèque C++ d'équivalents dans le même bloc de code.
  • stringName.c_str() tant que c'est un std::string, std::wstring, ou quelque chose comme un winrt::hstring.

InformationsquelleAutor user37875 | 2008-12-07
  1. 1000

    Si vous voulez juste passer un std::string à une fonction qui doit const char* vous pouvez utiliser 

    std::string str;
const char * c = str.c_str();

    Si vous souhaitez obtenir une copie accessible en écriture, comme char *, vous pouvez le faire avec cette:

    std::string str;
char * writable = new char[str.size() + 1];
std::copy(str.begin(), str.end(), writable);
writable[str.size()] = '
    std::string str;
char * writable = new char[str.size() + 1];
std::copy(str.begin(), str.end(), writable);
writable[str.size()] = '\0'; //don't forget the terminating 0
//don't forget to free the string after finished using it
delete[] writable;
    '    ; //don't forget the terminating 0

//don't forget to free the string after finished using it
delete[] writable;

    Modifier: à noter que le ci-dessus n'est pas une exception coffre-fort. Si quoi que ce soit entre les new appel et la delete appel jette, vous aurez une fuite de mémoire, que rien ne va appeler delete automatiquement pour vous. Il y a deux façons de résoudre ce problème.

    boost::scoped_array

    boost::scoped_array va supprimer de la mémoire pour vous au moment d'aller hors de portée:

    std::string str;
boost::scoped_array<char> writable(new char[str.size() + 1]);
std::copy(str.begin(), str.end(), writable.get());
writable[str.size()] = '
    std::string str;
boost::scoped_array<char> writable(new char[str.size() + 1]);
std::copy(str.begin(), str.end(), writable.get());
writable[str.size()] = '\0'; //don't forget the terminating 0
//get the char* using writable.get()
//memory is automatically freed if the smart pointer goes 
//out of scope
    '    ; //don't forget the terminating 0

//get the char* using writable.get()

//memory is automatically freed if the smart pointer goes 
//out of scope

    std::vector

    C'est la manière standard (ne nécessite aucune bibliothèque externe). Vous utilisez std::vector, qui gère complètement la mémoire pour vous.

    std::string str;
std::vector<char> writable(str.begin(), str.end());
writable.push_back('
    std::string str;
std::vector<char> writable(str.begin(), str.end());
writable.push_back('\0');
//get the char* using &writable[0] or &*writable.begin()
    '    );

//get the char* using &writable[0] or &*writable.begin()
    • Utilisez simplement char *result = strdup(str.c_str());
    • vous pourriez, mais strdup n'est pas un c ou c++ standard de la fonction, c'est à partir de posix 🙂
    • ce que je n'aurais sans doute préfèrent généralement est std::vector<char> écriture(str.begin(), str.end()); accessible en écriture.push_back('\0'); char * c = &inscriptible[0];
    • Vous pouvez également construire le vecteur avec: vector<char> écriture(str.c_str(), str.size() + 1);
    • Certainement utiliser std::vector. Allouer le tableau de char n'est pas une exception coffre-fort.
    • Je suis d'accord: litb, vous devez ajouter votre "vecteur" de la solution principale de votre réponse, car il est (à l'exception de-) plus sûr que les premières de new/delete solution.
    • ok, merci je vais les mettre là. vous m'avez convaincu
    • Je suis curieux de savoir pourquoi vous êtes pencher en arrière pour utiliser std::copy(). Ne pas utiliser la fonction strcpy( the_destination, str.c_str()) - ou strlcpy() si vous en avez un travail et ainsi être plus immédiatement évident que ce qui se passe? strcpy() fonctionne avec n'importe quel de scoped_array, vecteur, ou un brut de l'allocation de mémoire.
    • std::copy est le c++ façon de faire cela, sans la nécessité d'obtenir le pointeur de la chaîne. J'essaie d'éviter d'utiliser des fonctions C autant que je le peux.
    • +1 (j'ai été en attente pour l'exception safe plus)... ^_^
    • Qui vecteur constructeur est vector<char> writable(str.c_str(), str.size() + 1); à l'aide?
    • Baker: C'est un imaginaire ctor j'ai trouvé 🙂 j'ai mélangé avec des std::string s ctor (ou c'était peut-être un non-extension standard de VC6... frissonner). De toute façon, ma solution préférée est celle mentionnée dans litb du commentaire ci-dessus (avec début/fin que ces dossiers).
    • BTW, si vous utilisez quelque chose comme strdup(), vous devez appeler free() plus tard (par opposition à supprimer []).
    • Je te suggère c'est également le "C++ de manière à" simplement muter std::string en place comme son interface publique expose char &operator[]: c'est précisé et garanti de comportement.
    • Est char *p = const_cast<char*>(str.c_str()) une option (même mauvaise)?
    • J'étais jeune...pardonnez-moi. 🙁
    • Vous devez ajouter un commentaire "NE faites PAS CECI" à côté de la new char[..] déclaration. Je soupçonne que beaucoup de gens il suffit de copier/coller le code de l'échantillon, sans lire le texte d'accompagnement.
    • En tant que C++ néophyte, pourquoi ne pas simplement utiliser std::strcpy(dest, str.c_str())?
    • c'est tout à fait bien et j'aurais peut-être utilisé en véritable code aswell lors de la pressée 🙂 je voudrais juste utiliser std::copy quand j'ai le temps de faire de jolies code. N'oublions pas qu'il y a une différence (même s'il est peu probable que l'un avec de vraies cordes, mais qui sait ce qu'il va stocker). Le std::copy copie incorporé des octets nuls aswell, jusqu'à la fin de la std::string.
    • Pourquoi ne pas copier la chaîne et pass &copy[0] pour une écriture char* d'une taille fixe?
    • char* result = strcpy((char*)malloc(str.length()+1), str.c_str());
    • Au lieu de std::copy(str.begin(), str.end(), writable); writable[str.size()] = '\0';, pourquoi ne pas simplement utiliser std::copy(str.begin(),str.end() + 1,writable);?
    • parce qu'en C++03 qui n'était pas valide. Je ne suis pas sûr de ce que exactement à la règle en C++11 et C++14 est pour elle. Ils garantissent que la chaîne est nulle terminée et contigus, au moins
    • Ah, donc en 03 il n'était pas garanti d'avoir un terminateur null? Qui fait sens.
    • ce que je m'inquiète plus, c'est le end() + 1, pas tellement sur le terminateur null (je ne suis pas un expert de la bibliothèque, mais je ne pense pas que tout le populaire implémentations de la bibliothèque autour d'aujourd'hui ont std::string sans une fuite \0). Dans les versions debug, certaines implémentations de la bibliothèque ont des récipients où .end() renvoie un objet de classe qui jette/core dumps .end() + 1. Donc je ferais mieux d'être prudent et d'écrire un code que je sais avec certitude fonctionne 🙂
    • Cela semble incroyablement inutile, mais je suis sûr qu'il ya une raison pour cela. J'ai très rarement utiliser le C++ standard library et le bâton à la C stdlib, donc je n'ai pas eu beaucoup de pratique avec ces. Se serait attendu que .end() serait de retour d'un pointeur-taille int, ou quelque chose de similaire.
    • Pour le premier bloc de code, est-il profond ou peu profond copie qui est faite?
    • Les Solutions impliquant strcpy() ou strdup() peut échouer si le std::string contient des caractères null.
    • Au lieu de boost::scoped_array<char>, on peut aussi utiliser std::unique_ptr<char[]> de la STL: std::unique_ptr<char[]> writable(new char[str.size() + 1]);. Il libère également le tableau à l'aide de delete[] quand elle est hors de portée.
    • Que de C++17, std::string::data() maintenant, retourne un CharT* au lieu d'un const CharT*. Il pourrait être une bonne idée de mettre à jour cette réponse 🙂
    • Étant donné que les questions avec simplement l'aide de data ou &s[0] ont été fixés pour les trois libéré versions linguistiques maintenant, tout cela semble trop compliqué. Même si la chaîne est const, une simple copie de celui-ci devrait être suffisant.
    • veuillez les corriger. J'ai de la communauté wikied il
    • Heureux de donner de l'999th upvote 🙂

    InformationsquelleAutor
  2. 185

    Donné le dire...

    std::string x = "hello";

    L'obtention d'un `char *` ou de `const char*` d'une `chaîne`

    Comment obtenir un pointeur de caractère valide alors que x reste dans la portée et n'est pas modifié

    C++11 simplifie les choses; dans les cas suivants donnent tous accès à la même chaîne de la mémoire tampon:

    const char* p_c_str = x.c_str();
const char* p_data  = x.data();
char* p_writable_data = x.data(); //for non-const x from C++17 
const char* p_x0    = &x[0];

      char* p_x0_rw = &x[0];  //compiles iff x is not const...

    Tous les pointeurs tiendra le même valeur - l'adresse du premier caractère dans la mémoire tampon. Même une chaîne vide est un "premier caractère dans la mémoire tampon", parce que le C++11 garantit de toujours garder un extra NUL/0 caractère de terminaison après explicitement attribué chaîne de contenu (par exemple, std::string("this\0that", 9) aura un tampon holding "this\0that\0").

    Compte tenu de tout ce qui précède pointeurs:

    char c = p[n];   //valid for n <= x.size()
                 //i.e. you can safely read the NUL at p[x.size()]

    Seulement pour les non-const pointeur p_writable_data et de &x[0]:

    p_writable_data[n] = c;
p_x0_rw[n] = c;  //valid for n <= x.size() - 1
                 //i.e. don't overwrite the implementation maintained NUL

    L'écriture d'un NUL ailleurs dans la chaîne de ne pas changer le string's size(); string's sont autorisés à contenir n'importe quel nombre de NULs - ils ne sont pas un traitement spécial, par std::string (même en C++03).

    Dans C++03, les choses étaient beaucoup plus compliquées (les principales différences mis en évidence):

    • x.data()

      • retourne const char* de la chaîne de la mémoire tampon interne qui n'était pas requis par la Norme de conclure avec un NUL (c'est à dire peut-être ['h', 'e', 'l', 'l', 'o'] suivie par non initialisée ou de déchets de valeurs, avec accidentelle accède à y avoir comportement indéfini).
        • x.size() personnages sont sûrs à lire, c'est à dire x[0] par x[x.size() - 1]
        • pour les cordes à vide, vous avez la garantie de certains pointeur non NULL pour qui 0 peut être ajouté sans risque (youpi!), mais vous ne devriez pas déréférencer le pointeur.

    • &x[0]

      • pour les cordes à vide ce qui a un comportement indéterminé (21.3.4)
        • par exemple, étant donné f(const char* p, size_t n) { if (n == 0) return; ...whatever... } vous ne devez pas appeler f(&x[0], x.size()); quand x.empty() - il suffit d'utiliser f(x.data(), ...).
      • autrement, comme par x.data() mais:
        • pour les non-const x cela aboutit à un non-const char* pointeur; vous pouvez remplacer la chaîne de contenu

    • x.c_str()

      • retourne const char* à un ASCIIZ (NUL-fin) la représentation de la valeur (c'est à dire ['h', 'e', 'l', 'l', 'o', '\0']).
      • même si très peu d'implémentations ont choisi de le faire, le C++03 Standard a été rédigé afin de permettre la chaîne de mise en œuvre de la liberté de créer une distinctes NUL de terminaison de la mémoire tampon à la volée, de la zone potentiellement non-NUL résilié tampon "exposé" par x.data() et &x[0]
      • x.size() + 1 caractères sont sûrs à lire.
      • garanti en toute sécurité, même pour les cordes à vide (['\0']).

    Conséquences de l'accès, en dehors des indices

    N'importe quelle manière que vous obtenez un pointeur, vous ne devez pas accéder à la mémoire, plus loin le long du pointeur que les personnages de la garantie présents dans les descriptions ci-dessus. Tentatives n'ont comportement indéfini, avec une chance très réelle de l'application se bloque et les ordures résultats, même pour les lectures, et de plus gros, de données, de corruption de la pile et/ou des failles de sécurité pour les écritures.

    Moment ces pointeurs invalidé?

    Si vous appelez string fonction membre qui modifie la string ou se réserve en outre la capacité, toutes les valeurs de pointeur retourné à l'avance par l'une des méthodes ci-dessus sont invalidé. Vous pouvez utiliser ces méthodes pour obtenir un autre pointeur. (Les règles sont les mêmes que pour les itérateurs en strings).

    Voir aussi Comment obtenir un pointeur de caractère valide même après x champ d'application de feuilles ou est modifiée ci-dessous....

    Donc, ce qui est mieux à utiliser?

    À partir de C++11, utiliser .c_str() pour ASCIIZ de données, et .data() pour "binaire" des données (expliqué ci-dessous).

    En C++03, utilisez .c_str() moins certain que .data() est adéquate, et préférez .data() sur &x[0] comme il est sans danger pour les cordes à vide....

    ...essayer de comprendre le programme à utiliser data() le cas échéant, ou vous aurez probablement faire d'autres erreurs...

    Le code ASCII du caractère NUL '\0' caractère garanti par .c_str() est utilisé par de nombreuses fonctions comme une sentinelle de la valeur indiquant la fin de coffre-fort-à-l'accès aux données. Cela s'applique à la fois en C++des fonctions comme le disent fstream::fstream(const char* filename, ...) et partagé avec les fonctions C comme strchr(), et printf().

    Donné C++03 du .c_str()'s garanties sur le retour de la mémoire tampon sont un super-ensemble de .data()'s, vous pouvez toujours l'utiliser en toute sécurité .c_str(), mais parfois les gens ne le font pas car:

    • à l'aide de .data() communique à d'autres programmeurs lisant le code source que les données n'est pas ASCIIZ (plutôt, vous utilisez la chaîne pour stocker un bloc de données (qui parfois n'est même pas vraiment textuel)), ou que vous êtes de passage à une autre fonction qui le traite comme un bloc de "binaire" des données. Cela peut être une idée cruciale de veiller à ce que d'autres programmeurs modifications du code de continuer à traiter les données correctement.
    • C++03 seulement: il y a une petite chance que votre string mise en œuvre aurez besoin de faire quelques extra allocation de mémoire et/ou de copie de données dans le but de préparer le NUL résilié tampon

    Comme un autre indice, si une fonction des paramètres d'exiger de l' (const) char* mais de ne pas insister sur l'obtention de x.size(), la fonction probablement besoin d'un ASCIIZ d'entrée, de sorte .c_str() est un bon choix (la fonction a besoin de savoir où le texte se termine en quelque sorte, donc, si ce n'est pas un paramètre individuel, il ne peut être qu'une convention comme une longueur de préfixe ou de sentinelle ou de certains fixe la durée prévue).

    Comment obtenir un pointeur de caractère valide même après x champ d'application de feuilles ou est modifiée

    Vous aurez besoin de copie le contenu de la string x à une nouvelle zone de mémoire à l'extérieur x. Cette mémoire tampon peut être dans de nombreux endroits comme un autre string ou tableau de caractères de la variable, il peut ou peut ne pas avoir une autre vie que x en raison d'être dans un autre champ (par exemple, l'espace de noms global, statique, de segment de mémoire partagée, fichier mappé en mémoire).

    Pour copier le texte à partir de std::string x d'autonomie d'un tableau de caractères:

    //USING ANOTHER STRING - AUTO MEMORY MANAGEMENT, EXCEPTION SAFE
std::string old_x = x;
//- old_x will not be affected by subsequent modifications to x...
//- you can use `&old_x[0]` to get a writable char* to old_x's textual content
//- you can use resize() to reduce/expand the string
//  - resizing isn't possible from within a function passed only the char* address
std::string old_x = x.c_str(); //old_x will terminate early if x embeds NUL
//Copies ASCIIZ data but could be less efficient as it needs to scan memory to
//find the NUL terminator indicating string length before allocating that amount
//of memory to copy into, or more efficient if it ends up allocating/copying a
//lot less content.
//Example, x == "ab\0cd" -> old_x == "ab".
//USING A VECTOR OF CHAR - AUTO, EXCEPTION SAFE, HINTS AT BINARY CONTENT, GUARANTEED CONTIGUOUS EVEN IN C++03
std::vector<char> old_x(x.data(), x.data() + x.size());       //without the NUL
std::vector<char> old_x(x.c_str(), x.c_str() + x.size() + 1);  //with the NUL
//USING STACK WHERE MAXIMUM SIZE OF x IS KNOWN TO BE COMPILE-TIME CONSTANT "N"
//(a bit dangerous, as "known" things are sometimes wrong and often become wrong)
char y[N + 1];
strcpy(y, x.c_str());
//USING STACK WHERE UNEXPECTEDLY LONG x IS TRUNCATED (e.g. Hello\0->Hel\0)
char y[N + 1];
strncpy(y, x.c_str(), N);  //copy at most N, zero-padding if shorter
y[N] = '\0';               //ensure NUL terminated
//USING THE STACK TO HANDLE x OF UNKNOWN (BUT SANE) LENGTH
char* y = alloca(x.size() + 1);
strcpy(y, x.c_str());
//USING THE STACK TO HANDLE x OF UNKNOWN LENGTH (NON-STANDARD GCC EXTENSION)
char y[x.size() + 1];
strcpy(y, x.c_str());
//USING new/delete HEAP MEMORY, MANUAL DEALLOC, NO INHERENT EXCEPTION SAFETY
char* y = new char[x.size() + 1];
strcpy(y, x.c_str());
//    or as a one-liner: char* y = strcpy(new char[x.size() + 1], x.c_str());
//use y...
delete[] y; //make sure no break, return, throw or branching bypasses this
//USING new/delete HEAP MEMORY, SMART POINTER DEALLOCATION, EXCEPTION SAFE
//see boost shared_array usage in Johannes Schaub's answer
//USING malloc/free HEAP MEMORY, MANUAL DEALLOC, NO INHERENT EXCEPTION SAFETY
char* y = strdup(x.c_str());
//use y...
free(y);

    D'autres raisons de vouloir un char* ou const char* généré à partir d'un string

    Donc, ci-dessus, vous avez vu comment obtenir une (const) char*, et comment faire pour faire une copie du texte indépendant de l'original string, mais que pouvez-vous ne avec elle? Aléatoire d'une poignée d'exemples...

    • donner "C" code d'accès pour le C++ strings'du texte, comme dans printf("x is '%s'", x.c_str());
    • copie xs'du texte à un tampon spécifié par votre fonction de l'appelant (par exemple strncpy(callers_buffer, callers_buffer_size, x.c_str())), et la volatilité de la mémoire utilisée pour les e/S de périphérique (par exemple,for (const char* p = x.c_str(); *p; ++p) *p_device = *p;)
    • ajouter xs'du texte à un tableau de caractères contenant déjà quelques ASCIIZ du texte (par exemple strcat(other_buffer, x.c_str())) - attention à ne pas provoquer un dépassement de la mémoire tampon (dans de nombreux cas, vous pouvez avoir besoin d'utiliser strncat)
    • retour d'un const char* ou char* à partir d'une fonction (peut-être pour des raisons historiques - client à l'aide de votre API existantes - ou pour C compatibilité, vous ne voulez pas retourner un std::string, mais ne voulez copier votre stringde données de l'quelque part pour l'appelant)
      • être prudent de ne pas retourner un pointeur qui peut être déréférencé par l'appelant après, une string variable à laquelle le pointeur de relever a gauche de la portée
      • certains projets avec des objets partagés compilé/lien pour les différents std::string implémentations (par exemple STLport et le compilateur natif) peut transmettre des données comme ASCIIZ pour éviter les conflits
    • Une belle. Une autre raison de vouloir un char* (non const) est de fonctionner avec MPI de diffusion. Il semble plus agréable si vous n'avez pas à copier d'avant en arrière. J'aurais personnellement offert un char* const getter à la chaîne. Const pointeur, mais modifiable chaîne. Même si elle peut avoir gâché avec la conversion implicite de type const char* string...
    InformationsquelleAutor
  3. 33

    Utiliser le .c_str() méthode pour const char *.

    Vous pouvez utiliser &mystring[0] pour obtenir un char * pointeur, mais il ya un couple de gotcha: vous n'aurez pas nécessairement obtenir un zéro chaîne terminée, et vous ne serez pas en mesure de changer la chaîne de la taille. Vous devez être prudent de ne pas ajouter des personnages après la fin de la chaîne ou vous aurez un dépassement de la mémoire tampon (et probable crash).

    Il n'y a aucune garantie que tous les personnages feraient partie de la même contiguë de la mémoire tampon jusqu'à ce que le C++11, mais dans la pratique, connues de tous les implémentations de std::string travaillé de cette façon toute façon; voir N' “&s[0]” point de caractères contigus dans une std::string?.

    Noter que de nombreux string fonctions de membre va réallouer de la mémoire tampon interne et de l'invalider tous les pointeurs vous ont peut-être sauvé. Mieux les utiliser immédiatement et puis jetez-la.

    • vous devriez noter que les données() renvoie const char * 🙂 ce que tu veux dire, c'est &str[0], qui renvoie un contigus, mais pas necassary chaîne terminée par null.
    • Argh! C'est ce que je reçois pour essayer de concocter une réponse rapide. J'ai utilisé votre solution dans le passé, je ne sais pas pourquoi ce n'était pas la première chose qui vient à l'esprit. J'ai édité ma réponse.
    • Techniquement, std::string stockage seront contigus seulement dans C++0x.
    • merci je ne savais pas que. J'avais du mal à trouver une mise en œuvre alors que ce n'était pas le cas, cependant.
    • char* result = strcpy(malloc(str.length()+1), str.c_str());
    InformationsquelleAutor Mark Ransom
  4. 20

    C++17

    C++17 (norme à venir) modifie le synopsis du modèle basic_string l'ajout d'un non const surcharge de data():

    charT* data() noexcept;

    Retourne: Un pointeur p tels que p + i == &opérateur pour chaque i dans [0,size()].

    CharT const * de std::basic_string<CharT>

    std::string const cstr = { "..." };
char const * p = cstr.data(); //or .c_str()

    CharT * de std::basic_string<CharT>

    std::string str = { "..." };
char * p = str.data();

    C++11

    CharT const * de std::basic_string<CharT>

    std::string str = { "..." };
str.c_str();

    CharT * de std::basic_string<CharT>

    À partir de C++11, la norme dit:

    1. Le char comme des objets dans un basic_string objet doivent être stockés de manière contiguë. C'est, pour tout basic_string objet s, l'identité &*(s.begin() + n) == &*s.begin() + n tient pour toutes les valeurs de n tels que 0 <= n < s.size().

    1. const_reference operator[](size_type pos) const;
      reference operator[](size_type pos);

      Retourne: *(begin() + pos) si pos < size(), sinon, une référence à un objet de type CharT avec la valeur CharT(); la valeur de référence n'est pas modifiée.

    1. const charT* c_str() const noexcept;
      const charT* data() const noexcept;

      Retourne: Un pointeur p tel que p + i == &operator[](i) pour chaque i dans [0,size()].

    Il y a séparable des moyens possibles pour obtenir un non const pointeur de caractère.

    1. Utiliser la zone de stockage de C++11

    std::string foo{"text"};
auto p = &*foo.begin();

    Pro

    • Simple et court
    • Rapide (seule méthode avec aucune copie impliqués)

    Contre

    • Final '\0' ne sera pas modifié /ne faisant pas nécessairement partie de la non-const de la mémoire.

    2. Utilisation std::vector<CharT>

    std::string foo{"text"};
std::vector<char> fcv(foo.data(), foo.data()+foo.size()+1u);
auto p = fcv.data();

    Pro

    • Simple
    • Automatique de gestion de la mémoire
    • Dynamique

    Contre

    • Nécessite copie de chaîne

    3. Utilisation std::array<CharT, N> si N est compiler constante de temps (et d'assez petite taille)

    std::string foo{"text"};
std::array<char, 5u> fca;
std::copy(foo.data(), foo.data()+foo.size()+1u, fca.begin());

    Pro

    • Simple
    • Pile de gestion de la mémoire

    Contre

    • Statique
    • Nécessite copie de chaîne

    4. Brut de l'allocation de mémoire avec stockage automatique de suppression

    std::string foo{ "text" };
auto p = std::make_unique<char[]>(foo.size()+1u);
std::copy(foo.data(), foo.data() + foo.size() + 1u, &p[0]);

    Pro

    • Petite empreinte mémoire
    • De suppression automatique
    • Simple

    Contre

    • Nécessite copie de chaîne
    • Statique (dynamique de l'utilisation nécessite beaucoup plus de code)
    • Moins de fonctionnalités que vecteur ou d'une matrice

    5. Brut de l'allocation de mémoire avec la manutention manuelle

    std::string foo{ "text" };
char * p = nullptr;
try
{
p = new char[foo.size() + 1u];
std::copy(foo.data(), foo.data() + foo.size() + 1u, p);
//handle stuff with p
delete[] p;
}
catch (...)
{
if (p) { delete[] p; }
throw;
}

    Pro

    • Maximum de "contrôle"

    Con

    • Nécessite copie de chaîne
    • Maximum de responsabilité et de sensibilité pour les erreurs
    • Complexe
    InformationsquelleAutor Pixelchemist
  5. 9

    Je travaille avec une API avec beaucoup de fonctions comme un entrée d'un char*.

    J'ai créé une petite classe pour faire face à ce genre de problème, j'ai mis en œuvre l'idiome RAII.

    class DeepString
{
DeepString(const DeepString& other);
DeepString& operator=(const DeepString& other);
char* internal_; 
public:
explicit DeepString( const string& toCopy): 
internal_(new char[toCopy.size()+1]) 
{
strcpy(internal_,toCopy.c_str());
}
~DeepString() { delete[] internal_; }
char* str() const { return internal_; }
const char* c_str()  const { return internal_; }
};

    Et vous pouvez l'utiliser comme:

    void aFunctionAPI(char* input);
// other stuff
aFunctionAPI("Foo"); //this call is not safe. if the function modified the 
//literal string the program will crash
std::string myFoo("Foo");
aFunctionAPI(myFoo.c_str()); //this is not compiling
aFunctionAPI(const_cast<char*>(myFoo.c_str())); //this is not safe std::string 
//implement reference counting and 
//it may change the value of other
//strings as well.
DeepString myDeepFoo(myFoo);
aFunctionAPI(myFoo.str()); //this is fine

    J'ai appelé la classe DeepString parce que c'est la création d'un profond et unique exemplaire (le DeepString n'est pas copiable) d'une chaîne existante.

    • Je voudrais éviter cette convention de nommage. c_str() utilisé par std est une abréviation pour "C-string" pas "const string" et str() retourne toujours une std::basic_string, pas char* (par exemple std::stringstream::str())
    InformationsquelleAutor Alessandro Teruzzi
  6. 7
    char* result = strcpy((char*)malloc(str.length()+1), str.c_str());
    • semble compliqué, mais vraiment dur à comprendre... Simple est le meilleur de l'OMI
    • strcpy(), la fonction malloc(), longueur() et c_str() sont des fonctions de base et il n'y a rien de difficile dans cette. Juste allouer de la mémoire et de la copie.
    • oui les fonctions sont basiques, mais vous avez tordu et plié à ressembler à un bol de spaghetti ou un liner monstre 🙂
    • Oui les fonctions sont basiques, mais... avez-vous rappelez-vous quand vous commencer à traiter avec un langage de programmation? Quelques lignes de plus pour expliquer et il va vraiment aider un néophyte d'apprendre pourquoi, par exemple, est différent ou de mieux que cette réponse🙂
    • Chaque fois qu'il y a un malloc(), il doit aussi y avoir un free(). Sinon, le code des fuites de mémoire, et donc, la solution dans votre réponse. L'allocation de mémoire sans au moins une allusion à la libération de la mémoire est une mauvaise pratique pour de telles questions.
    InformationsquelleAutor cegprakash
  7. 7

    Viens de voir ceci :

    string str1("stackoverflow");
const char * str2 = str1.c_str();

    Cependant , notez qu'il sera de retour un const char *.Pour un char *, utilisez strcpy pour le copier dans un autre char tableau.

    • Salut, ce que vous avez posté a déjà été dit plusieurs fois, avec plus de détails, en d'autres réponses aux 5 ans question. C'est bien pour répondre à des plus anciennes questions, mais uniquement si vous ajoutez de nouvelles informations. Sinon, c'est juste du bruit.
    • Personnellement, j'apprécie la simplicité.
    InformationsquelleAutor devsaw
  8. -4

    Essayer cette 

    std::string s(reinterpret_cast<const char *>(Data), Size);
    InformationsquelleAutor anish