convertir - str to char array c++

cómo copiar char*en una cadena y viceversa

Question

Si paso un char * en una función. Luego quiero tomar ese char * convertirlo en std :: string y una vez que obtenga mi resultado, volverlo a convertir a char * desde un std :: string para mostrar el resultado.

1. No sé cómo hacer esto para la conversión (no estoy hablando const char * pero solo char *)
2. No estoy seguro de cómo manipular el valor del puntero que envío.

así que pasos tengo que hacer

1. tomar en una char *
2. convertirlo en una cadena.
3. tomar el resultado de esa cadena y volver a ponerlo en forma de char *
4. devuelva el resultado de manera que el valor esté disponible fuera de la función y no se destruya.

De ser posible, puedo ver cómo se puede hacer a través de la referencia frente a un puntero (cuya dirección paso por valor, sin embargo, todavía puedo modificar el valor al que apunta el puntero. Así que incluso la copia de la dirección del puntero en la función se destruye Todavía veo el valor cambiado fuera.

¡Gracias!

Answer 1

Debe observar cómo maneja la memoria desde el puntero que devuelve, por ejemplo, el código siguiente no funcionará porque la memoria asignada en la cadena std :: se liberará cuando salga fn ().

const char* fn(const char*psz) {
    std::string s(psz);
    // do something with s
    return s.c_str();   //BAD
}

Una solución es asignar la memoria a la función y asegurarse de que la persona que llama a la función la libere:

const char* fn(const char*psz) {
    std::string s(psz);
    // do something with s
    char *ret = new char[s.size()]; //memory allocated
    strcpy(ret, s.c_str());
    return ret;
}
....
const char* p = fn("some text");
//do something with p
delete[] p;// release the array of chars

Alternativamente, si conoce un límite superior en el tamaño de la cadena, puede crearlo en la pila usted mismo y pasar un puntero, por ejemplo

void fn(const char*in size_t bufsize, char* out) { 
    std::string s(psz);
    // do something with s
    strcpy_s(out, bufsize, s.c_str()); //strcpy_s is a microsoft specific safe str copy
}
....
const int BUFSIZE = 100;
char  str[BUFSIZE];

fn("some text", BUFSIZE, str);
//ok to use str (memory gets deleted when it goes out of scope)

Answer 2

Puede mantener un recolector de basura para su biblioteca implementado como std::vector<char*> g_gc; que es accesible en su biblioteca ''lib''. Más tarde, puede liberar todos los punteros en g_gc a su conveniencia llamando a lib::release_garbage();

char* lib::func(char*pStr)
{
  std::string str(pStr);
  char *outStr = new char[str.size()+1];
  strcpy(outStr, str.c_str());
  g_gc.push_back(outStr); // collect garbage
  return outStr;
}

La función release_garbage se verá así:

void lib::release_garbage()
{
   for(int i=0;i<g_gc.size();i++)
   {
       delete g_gc[i];
   }
   g_gc.clear();
}

En un modelo de un solo hilo, puede mantener esta g_gc estática. El modelo multihilo implicaría bloquearlo / desbloquearlo.

Answer 3

Convertir un char* a un std::string :

char* c = "Hello, world";
std::string s(c);

Convertir un std::string a un char* :

std::string s = "Hello, world";
char* c = new char[s.length() + 1];
strcpy(c, s.c_str());

// and then later on, when you are done with the `char*`:
delete[] c;

Prefiero usar un std::vector<char> lugar de un char* real char* ; entonces no tienes que administrar tu propia memoria:

std::string s = "Hello, world";
std::vector<char> v(s.begin(), s.end());
v.push_back(''/0''); // Make sure we are null-terminated
char* c = &v[0];