std :: string to char *

Je veux convertir une chaîne std :: en un type de données char * ou char [] .

std::string str = "string";
char* chr = str;

Résultats: "erreur: impossible de convertir 'std :: string' en 'char' ..." .

Quelles sont les méthodes disponibles pour ce faire?

Il ne se convertira pas automatiquement (Dieu merci). Vous devrez utiliser la méthode c_str()pour obtenir la version de la chaîne C.

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

Notez qu'il renvoie un const char *; vous n'êtes pas autorisé à modifier la chaîne de style C renvoyée par c_str(). Si vous souhaitez le traiter, vous devrez d'abord le copier:

std::string str = "string";
char *cstr = new char[str.length() + 1];
strcpy(cstr, str.c_str());
// do stuff
delete [] cstr;

Ou en C ++ moderne:

std::vector<char> cstr(str.c_str(), str.c_str() + str.size() + 1);

Plus de détails ici , et ici mais vous pouvez utiliser

string str = "some string" ;
char *cstr = &str[0];

Si j'avais besoin d'une copie brute modifiable du contenu d'une chaîne c ++, alors je ferais ceci:

std::string str = "string";
char* chr = strdup(str.c_str());

et ensuite:

free(chr); 

Alors pourquoi ne pas jouer avec std :: vector ou new [] comme n'importe qui d'autre? Parce que quand j'ai besoin d'une chaîne char * brute de style C mutable, alors parce que je veux appeler le code C qui change la chaîne et le code C désalloue les choses avec free () et alloue avec malloc () (strdup utilise malloc) . Donc, si je passe ma chaîne brute à une fonction X écrite en C, cela pourrait avoir une contrainte sur son argument qu'elle doit allouer sur le tas (par exemple si la fonction peut vouloir appeler realloc sur le paramètre). Mais il est très peu probable qu'il attende un argument alloué avec (certains redéfinis par l'utilisateur) new []!

_{(Cette réponse s'applique uniquement à C ++ 98.)}

S'il vous plaît, n'utilisez pas de brut char*.

std::string str = "string";
std::vector<char> chars(str.c_str(), str.c_str() + str.size() + 1u);
// use &chars[0] as a char*

• Si vous voulez juste une chaîne de style C représentant le même contenu:

  char const* ca = str.c_str();

• Si vous voulez une chaîne de style C avec un nouveau contenu, une façon (étant donné que vous ne connaissez pas la taille de la chaîne au moment de la compilation) est l'allocation dynamique:

  char* ca = new char[str.size()+1];
  std::copy(str.begin(), str.end(), ca);
  ca[str.size()] = '\0';

  N'oubliez pas delete[]plus tard.

• Si vous souhaitez plutôt un tableau alloué statiquement et de longueur limitée:

  size_t const MAX = 80; // maximum number of chars
  char ca[MAX] = {};
  std::copy(str.begin(), (str.size() >= MAX ? str.begin() + MAX : str.end()), ca);

std::stringne se convertit pas implicitement à ces types pour la simple raison que le faire est généralement une odeur de conception. Assurez-vous d'en avoir vraiment besoin.

Si vous en avez vraiment besoin char*, la meilleure façon est probablement:

vector<char> v(str.begin(), str.end());
char* ca = &v[0]; // pointer to start of vector

Ce serait mieux comme un commentaire sur la réponse de Bobobobo, mais je n'ai pas de représentant pour cela. Il accomplit la même chose mais avec de meilleures pratiques.

Bien que les autres réponses soient utiles, si vous avez besoin de convertir std::stringen char*explicit sans const, const_castc'est votre ami.

std::string str = "string";
char* chr = const_cast<char*>(str.c_str());

Notez que cela ne vous donnera pas une copie des données; il vous donnera un pointeur sur la chaîne. Ainsi, si vous modifiez un élément de chr, vous modifierez str.

En supposant que vous ayez juste besoin d'une chaîne de style C pour passer en entrée:

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

Pour être strictement pédant, vous ne pouvez pas "convertir une chaîne std :: en un type de données char * ou char []."

Comme les autres réponses l'ont montré, vous pouvez copier le contenu de la chaîne std :: dans un tableau char, ou créer un const char * dans le contenu de la chaîne std :: afin de pouvoir y accéder dans un "style C" .

Si vous essayez de changer le contenu de la chaîne std ::, le type std :: string possède toutes les méthodes pour faire tout ce dont vous pourriez avoir besoin.

Si vous essayez de le passer à une fonction qui prend un char *, il y a std :: string :: c_str ().

Voici une version plus robuste de Protocol Buffer

char* string_as_array(string* str)
{
    return str->empty() ? NULL : &*str->begin();
}

// test codes
std::string mystr("you are here");
char* pstr = string_as_array(&mystr);
cout << pstr << endl; // you are here

Conversion dans le style OOP

converter.hpp

class StringConverter {
    public: static char * strToChar(std::string str);
};

converter.cpp

char * StringConverter::strToChar(std::string str)
{
    return (char*)str.c_str();
}

usage

StringConverter::strToChar("converted string")

Pour être complet, n'oubliez pas std::string::copy().

std::string str = "string";
const size_t MAX = 80;
char chrs[MAX];

str.copy(chrs, MAX);

std::string::copy()NUL ne se termine pas. Si vous devez garantir un terminateur NUL pour une utilisation dans les fonctions de chaîne C:

std::string str = "string";
const size_t MAX = 80;
char chrs[MAX];

memset(chrs, '\0', MAX);
str.copy(chrs, MAX-1);

Vous pouvez le faire en utilisant l'itérateur.

std::string str = "string";
std::string::iterator p=str.begin();
char* chr = &(*p);

Bonne chance.

Une version sûre de la réponse char * d'orlp en utilisant unique_ptr:

std::string str = "string";
auto cstr = std::make_unique<char[]>(str.length() + 1);
strcpy(cstr.get(), str.c_str());

Pour obtenir un à const char *partir d'une std::stringutilisation de la c_str()fonction membre:

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

Pour obtenir un non-const à char *partir d'un, std::stringvous pouvez utiliser la data()fonction membre qui retourne un pointeur non-const depuis C ++ 17:

std::string str = "string";
char* chr = str.data();

Pour les anciennes versions du langage, vous pouvez utiliser la construction de plages pour copier la chaîne dans un vecteur à partir duquel un pointeur non const peut être obtenu:

std::string str = "string";
std::vector<char> str_copy(str.c_str(), str.c_str() + str.size() + 1);
char* chr = str_copy.data();

Mais attention, cela ne vous permettra pas de modifier la chaîne contenue dans str, seules les données de la copie peuvent être modifiées de cette façon. Notez qu'il est particulièrement important dans les anciennes versions de la langue d'utiliser c_str()ici, car à l'époque, il std::stringn'était pas garanti que la terminaison null soit terminée jusqu'à ce qu'elle c_str()soit appelée.

char* result = strcpy((char*)malloc(str.length()+1), str.c_str());

Alternativement, vous pouvez utiliser des vecteurs pour obtenir un caractère inscriptible * comme illustré ci-dessous;

//this handles memory manipulations and is more convenient
string str;
vector <char> writable (str.begin (), str.end) ;
writable .push_back ('\0'); 
char* cstring = &writable[0] //or &*writable.begin () 

//Goodluck  

Cela fonctionnera également

std::string s;
std::cout<<"Enter the String";
std::getline(std::cin, s);
char *a=new char[s.size()+1];
a[s.size()]=0;
memcpy(a,s.c_str(),s.size());
std::cout<<a;