std:: string to char*

Więcej szczegółów tutaj i tutaj ale możesz użyć

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

Jeśli potrzebowałbym mutowalnej, surowej kopii zawartości ciągów c++, to zrobiłbym to:

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

I Później:

free(chr); 

Więc dlaczego nie mogę bawić się std:: vector lub new[] jak ktoś inny? Ponieważ Kiedy potrzebuję zmiennego łańcucha znaków* w stylu C, to ponieważ chcę wywołać kod C, który zmienia łańcuch, a kod C deallocuje rzeczy za pomocą free() i przydziela za pomocą malloc () (strdup używa malloc) . Więc jeśli przekażę mój surowy ciąg do jakiejś funkcji X zapisanej w C to może mieć ograniczenie co do argumentu, który ma być przypisany do sterty (na przykład, jeśli funkcja może chcieć wywołać realloc na parametrze). Ale jest bardzo mało prawdopodobne, aby oczekiwał argumentu przydzielonego (jakiś user-redefinited) new []!

_{(Ta odpowiedź dotyczy tylko C++98.)}

Proszę, nie używaj surowego char*.

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

• Jeśli chcesz tylko ciąg znaków w stylu C reprezentujący tę samą treść:

  char const* ca = str.c_str();
  

• Jeśli chcesz mieć łańcuch w stylu C z nową zawartością , jednym ze sposobów (biorąc pod uwagę, że nie znasz rozmiaru łańcucha w czasie kompilacji) jest dynamiczna alokacja:

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

  Nie zapomnij później.

• Jeśli zamiast tego chcesz statycznie przydzieloną tablicę o ograniczonej długości:

  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::string nie przekonwertuje do tych typów dla prosty powód, że potrzeba tego jest zwykle zapachem projektu. Upewnij się, że naprawdę tego potrzebujesz.

Jeśli zdecydowanie potrzebujesz char*, najlepszy sposób to prawdopodobnie:

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

To byłoby lepsze jako komentarz do odpowiedzi bobobobo, ale nie mam do tego reputacji. Osiąga to samo, ale z lepszymi praktykami.

Chociaż inne odpowiedzi są przydatne, jeśli kiedykolwiek potrzebujesz przekonwertować std::string na char* jawnie bez const, const_cast jest twoim przyjacielem.

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

Zauważ, że to nie da ci kopię danych; da ci wskaźnik do ciągu znaków. Tak więc, jeśli zmodyfikujesz element chr, zmodyfikujesz str.

Zakładając, że potrzebujesz tylko ciągu w stylu C, aby przekazać jako wejście:

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

Aby być ściśle pedantycznym, nie można "przekonwertować std::string na typ danych char * lub char []."

Jak pokazały inne odpowiedzi, możesz skopiować zawartość łańcucha znaków std:: do tablicy znaków lub utworzyć znak const * do zawartości łańcucha znaków std::, aby uzyskać do niego dostęp w "stylu C".

Jeśli próbujesz zmienić zawartość std:: string, Typ std::string zawiera wszystkie metody, aby zrobić z nim wszystko, co może być konieczne.

Jeśli jesteś próbując przekazać go do jakiejś funkcji, która przyjmuje znak*, jest std:: string:: c_str ().

Ze względu na kompletność, nie zapomnij std::string::copy().

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

str.copy(chrs, MAX);

std::string::copy() nie kończy się. Jeśli musisz zapewnić terminator NUL do użycia w funkcjach ciągów C:

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

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

Oto jeszcze jedna wersja z 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

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

Alternatywnie można użyć wektorów, aby uzyskać zapisywalny znak*, jak pokazano poniżej;

//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  

Możesz to zrobić używając iteratora.

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

To również zadziała

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;  

Bezpieczna wersja char* odpowiedzi orlp za pomocą unique_ptr:

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