std :: string to char *

Chcę przekonwertować std :: string na typ danych char * lub char [] .

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

Powoduje: „błąd: nie można przekonwertować 'std :: string' na 'char' ...” .

Jakie są dostępne metody, aby to zrobić?

Nie zamieni się automatycznie (dzięki Bogu). Musisz użyć tej metody, c_str()aby uzyskać wersję ciągu C.

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

Zauważ, że zwraca a const char *; nie mogą zmienić ciąg C-styl zwrócony przez c_str(). Jeśli chcesz go przetworzyć, musisz go najpierw skopiować:

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

Lub we współczesnym C ++:

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

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

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

Gdybym potrzebował modyfikowalnej, surowej kopii zawartości łańcucha c ++, zrobiłbym to:

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

i później:

free(chr); 

Dlaczego więc nie będę majstrować przy standardzie std :: vector lub new [] jak ktokolwiek inny? Ponieważ gdy potrzebuję zmiennego surowego łańcucha char * w stylu C, to dlatego, że chcę wywołać kod C, który zmienia łańcuch, a kod C zwalnia rzeczy za pomocą free () i przydziela za pomocą malloc () (strdup używa malloc) . Więc jeśli przekażę mój nieprzetworzony ciąg do funkcji X napisanej w C , może on mieć ograniczenie w argumencie, który musi przypisać na stercie (na przykład, jeśli funkcja może chcieć wywołać realloc dla parametru). Ale jest bardzo mało prawdopodobne, że spodziewałby się argumentu przypisanego (niektórym przedefiniowanym przez użytkownika) nowemu []!

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

Proszę nie używać 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 w stylu C reprezentujący tę samą treść:

  char const* ca = str.c_str();

• Jeśli chcesz łańcucha 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 alokacja dynamiczna:

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

  Nie zapomnij o delete[]tym później.

• Jeśli zamiast tego chcesz mieć 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::stringnie dokonuje domyślnej konwersji na te typy z tego prostego powodu, że konieczność wykonania tego jest zwykle zapachem projektowym. Upewnij się, że naprawdę potrzebujesz.

Jeśli zdecydowanie potrzebujesz char*, najlepszym sposobem jest prawdopodobnie:

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

Byłoby to lepsze jako komentarz do odpowiedzi bobobobo, ale nie mam za to przedstawiciela. Osiąga to samo, ale dzięki lepszym praktykom.

Chociaż inne odpowiedzi są przydatne, jeśli kiedykolwiek będziesz musiał przejść std::stringna char*jawnie bez const, const_castto twój przyjaciel.

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

Pamiętaj, że nie da ci to kopii danych; da ci wskaźnik do łańcucha. Zatem jeśli zmodyfikujesz element chr, zmodyfikujesz str.

Zakładając, że potrzebujesz tylko łańcucha w stylu C, aby przekazać jako dane wejściowe:

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

Aby być ściśle pedantycznym, nie można „konwertować parametru std :: string na typ danych char * lub char [].”

Jak pokazały inne odpowiedzi, możesz skopiować zawartość std :: string do tablicy char lub utworzyć const char * do zawartości std :: string, abyś mógł uzyskać do niej dostęp w stylu „C” .

Jeśli próbujesz zmienić zawartość std :: string, typ std :: string ma wszystkie metody, aby zrobić wszystko, co może być potrzebne.

Jeśli próbujesz przekazać go do jakiejś funkcji, która przyjmuje char *, istnieje std :: string :: c_str ().

Dla kompletności 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ę NUL. 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 solidna 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

Konwersja w stylu OOP

konwerter.hpp

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

konwerter.cpp

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

stosowanie

StringConverter::strToChar("converted string")

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ć za pomocą iteratora.

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

Powodzenia.

Bezpieczna wersja odpowiedzi char * orlp przy użyciu unikalnego_ptr:

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

Aby uzyskać const char *z std::stringużycia c_str()funkcji członka:

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

Aby uzyskać non-const char *z an std::string, możesz użyć data()funkcji członka, która zwraca wskaźnik non-const od C ++ 17:

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

W starszych wersjach języka można użyć konstrukcji zakresu, aby skopiować ciąg do wektora, z którego można uzyskać wskaźnik niezmienny:

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

Ale uwaga: nie pozwoli to na modyfikację zawartego w nim ciągu str, tylko dane kopii można zmienić w ten sposób. Zauważ, że jest to szczególnie ważne w starszych wersjach tego języka c_str(), ponieważ w tamtych czasach std::stringnie było gwarantowane, że zostanie zakończone zerowo, dopóki nie c_str()zostanie wywołane.

To też 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;