c++ - array - std:: string to char*

string to char* arduino

Question

Quiero convertir un std :: string en un tipo de datos char * o char [] .

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

Resultados en: "error: no se puede convertir ''std :: string'' a ''char'' ..." .

¿Qué métodos hay disponibles para hacer esto?

Answer 1

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

Answer 2

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

Answer 3

Conversión en estilo OOP

convertidor.hpp

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

converter.cpp

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

uso

StringConverter::strToChar("converted string")

Answer 4

Esto sería mejor como comentario sobre la respuesta de Bobobobo, pero no tengo la reputación para eso. Se 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 .

Answer 5

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;

Answer 6

No se convertirá automáticamente (gracias a Dios). Tendrás que usar el método c_str() para obtener la versión de la cadena C.

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

Tenga en cuenta que devuelve un const char * ; no se le permite cambiar la cadena de estilo C devuelta por c_str() . Si quieres procesarlo tendrás que copiarlo primero:

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

O en el moderno C ++:

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

Answer 7

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

std::string str = "string";
const size_t MAX = 80;
char chrs[MAX];
str.copy(chrs, MAX);

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

std::string str = "string";
const size_t MAX = 80;
char chrs[MAX];
memset(chrs, ''/0'', MAX);
str.copy(chrs, MAX-1);

Answer 8

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

Como se muestra en las otras respuestas, puede copiar el contenido de la cadena std :: string a una matriz de caracteres, o hacer un carácter const const * al contenido de la cadena std :: para que pueda acceder a él en un "estilo C" .

Si está intentando cambiar el contenido de std :: string, el tipo std :: string tiene todos los métodos para hacer todo lo que pueda necesitar.

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

Answer 9

Puedes hacerlo usando iterador.

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

Buena suerte.

Answer 10

Si necesitaría una copia en bruto mutable del contenido de la cadena de un c ++, entonces haría esto:

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

y después:

free(chr);

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

Answer 11

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

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

Answer 12

Una versión segura de orlp''s char * answer usando unique_ptr:

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

Answer 13

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

Por favor, no utilices un char* crudo char* .

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

Answer 14

Más detalles aquí , y here pero puedes usar

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

Answer 15

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

Answer 16

• Si solo quieres una cadena de estilo C que represente el mismo contenido:

  char const* ca = str.c_str();

• Si desea una cadena de estilo C con nuevos contenidos, una forma (dado que no sabe 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[] más tarde.

• Si quiere una matriz de longitud limitada y asignada estáticamente:

  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 se convierte implícitamente a estos tipos por la sencilla razón de que la necesidad de hacer esto suele ser un olor a diseño. Asegúrese de que realmente lo necesita.

Si definitivamente necesitas un char* , la mejor manera es probablemente:

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