std::string la char*

Nu o't converti automat (multumesc lui dumnezeu). Te'll trebuie să utilizeze metoda c_str() pentru a obține C string versiune.

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

Rețineți că, se întoarce o const char *; nu't permis să schimbe C-stil șirul returnat de c_str(). Dacă doriți să proces te'll trebuie să-l copiați în primul rând:

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

Sau în modern C++:

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

Detalii aici, și aici dar puteți folosi

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

Dacă am'd nevoie de un mutabil prime copie a unui c++'s string conținutul, apoi m-am'd a face acest lucru:

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

și mai târziu:

free(chr); 

Deci, de ce nu't am juca cu std::vector sau nou[] ca oricine altcineva? Pentru că atunci când am nevoie de un mutabil C-stil raw char* șir, apoi, pentru că vreau să sun C cod care se schimbă șirul și C cod deallocates chestia cu free() și alocă cu malloc() (strdup folosește malloc). Deci, dacă am trece mele șir prime pentru o funcție X scris în C l ar putea o constrângere pe l's argument că trebuie să alocat pe heap (de exemplu, dacă funcția ar putea dori pentru a apela realloc pe parametru). Dar este foarte puțin probabil că va aștepta un argument alocate cu (unele de utilizator redefinit) nou[]!

(Acest răspuns se aplică la C++98 numai.)

Te rog, nu't folosi o prime char*.

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

• Dacă doriți doar o C-style șir reprezentând același conținut:

const char* ca = str.c_str();

• Dacă doriți un C-style șir cu new conținutul, într-un fel (având în vedere că tu nu't știu șir dimensiunea la compilare-timp) este alocarea dinamică:

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

Don't uitați să delete[] de ea mai târziu.

• Dacă doriți un static alocat, limitat matrice de lungime în loc:

size_t const MAX = 80; // numărul maxim de caractere char ca[MAX] = {}; std::copy(str.begin(), (str.size() >= MAX ? str.begin() + MAX : str.end()), ca);

std::string nu't, implicit, de a converti la aceste tipuri pentru simplul motiv că au nevoie pentru a face acest lucru este de obicei un design miros. Asigurați-vă că really nevoie de ea.

Dacă tu siguranță nevoie de un char*, la best mod este, probabil:

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

Acest lucru ar fi mai bine ca un comentariu pe bobobobo's a răspuns, dar eu nu't au rep pentru asta. Se realizează același lucru dar cu mai bune destinații de plasare.

Deși alte răspunsuri sunt utile, dacă aveți vreodată nevoie pentru a converti std::string " la " char* în mod explicit, fără const, const_cast este prietenul tău.

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

Rețineți că acest lucru va nu da o copie a datelor; aceasta vă va da un pointer la șir de caractere. Astfel, dacă modificați un element de chr, ai'll modifica str.

Presupunând că ai nevoie doar de un C-style șir să treacă drept de intrare:

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

Să fie strict pedant, nu "a converti un std::string într-un char* sau char[] tip de date."

Ca alte răspunsuri au arătat, puteți copia conținutul std::string pentru a o matrice char, sau de a face o const char* conținutul de std::string, astfel încât să puteți accesa într-un "stilul C".

Daca're încercarea de a schimba conținutul std::string, std::string tip de metode pentru a face ceva ce ai putea avea nevoie pentru a face pentru ea.

Daca're încercarea de a trece de la o funcție care ia un char*, nu's std::string::c_str().

Pentru completitudine' dumnezeu, don't uita std::string::copy().

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

str.copy(chrs, MAX);

std::string::copy() nu't NUL termina. Dacă aveți nevoie pentru a asigura un terminator NUL pentru utilizarea în șir C funcții:

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

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

Aici este unul mai robust versiune de Protocol Tampon`

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 

Puteți face aceasta folosind iterator.

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

Noroc.

Alternativ , puteți folosi vectori pentru a obține o scriere char* cum s-a demonstrat de mai jos;

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

//Goodluck  

Conversie în stil OOP

convertor.che

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

converter.cpp

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

utilizare

StringConverter::strToChar("converted string")

Acest lucru va lucra, de asemenea,

std::string s;
std::cout

O versiune sigura de orlp's char* răspunde folosind unique_ptr:

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