std:: string to char*

Más detalles aquí, y aquí, pero se puede utilizar

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

Si necesitara una copia raw mutable del contenido de una cadena de c++, entonces haría esto:

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

Y posteriores:

free(chr); 

Entonces, ¿por qué no juego con std::vector o new [] como cualquier otra persona? Porque cuando necesito una cadena de caracteres raw mutable de estilo C, entonces porque quiero llamar a código C que cambia la cadena y el código C desasigna cosas con free() y asigna con malloc() (strdup usa malloc). Así que si paso mi cadena raw a alguna función X escrita en C podría tener una restricción en su argumento que tiene que asignar en el montón (por ejemplo, si la función podría querer llamar a realloc en el parámetro). Pero es muy poco probable que se esperaría un argumento asignado con (algunos usuario redefinido) nuevo []!

_{(Esta respuesta solo se aplica a C++98.)}

Por favor, no uses un raw 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 solo desea una cadena de estilo C que represente el mismo contenido:

  char const* ca = str.c_str();
  

• Si desea una cadena de estilo C con nuevo contenido , una forma (dado que no conoce el tamaño de la cadena en tiempo de compilación) es la asignación dinámica:

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

  No te olvides de delete[] después.

• Si desea una matriz de longitud limitada y asignada estáticamente en su lugar:

  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 no convierte implícitamente a estos tipos para el la razón simple que necesita hacer esto es generalmente un olor del diseño. Asegúrate de que realmente lo necesitas.

Si definitivamente necesita un char*, el mejor a es probablemente:

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

Esto sería mejor como un comentario sobre la respuesta de bobobobo, pero no tengo el rep para eso. Logra lo mismo pero con mejores prácticas.

Aunque las otras respuestas son útiles, si alguna vez necesitas convertir std::string a char* explícitamente sin const, const_cast es tu amigo.

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

Tenga en cuenta que esto no le dará una copia de los datos; le dará un puntero a la cadena. Por lo tanto, si modifica un elemento de chr, modificará str.

Suponiendo que solo necesita una cadena de estilo C para pasar como entrada:

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

Para ser estrictamente pedante, no puede "convertir una cadena std::en un tipo de datos char* o char []."

Como han mostrado las otras respuestas, puede copiar el contenido de la cadena std::a una matriz char, o hacer un const char* al contenido de la cadena std::para que pueda acceder a ella en un "estilo C".

Si está tratando de cambiar el contenido de la cadena std::, el tipo std::string tiene todos los métodos para hacer cualquier cosa que pueda necesitar.

Si eres tratando de pasarlo a alguna función que toma un char*, está std:: string:: c_str().

Para completar' sake, no se olvide std::string::copy().

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

str.copy(chrs, MAX);

std::string::copy() no termina. Si necesita asegurar un terminador NUL para su uso en funciones de cadena de C:

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

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

Aquí hay una versión más robusta 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

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

Alternativamente, puede usar vectores para obtener un carácter escribible * como se muestra a continuación;

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

Puedes hacerlo usando el iterador.

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

Buena suerte.

Esto también funcionará

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;  

Una versión segura de la respuesta char* de orlp usando unique_ptr:

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