cómo copiar char * en una cadena y viceversa

Question

Si paso una char * en una función. Quiero entonces tomar ese char * convertirlo a std :: string y una vez que obtengo mi resultado convertirlo de nuevo a char * desde std :: string para mostrar el resultado.

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

así los pasos que tengo que hacer

1. toma en un char *
2. convertirlo en una cadena.
3. tome el resultado de esa cadena y vuelva a colocarla en forma de un carácter *
4. devuelva el resultado de manera que el valor esté disponible fuera de la función y no se destruya.

Si es posible, puedo ver cómo se puede hacer a través de la referencia contra un puntero (cuya dirección paso por valor pero puedo modificar el valor al que apunta el puntero) aunque la copia del puntero dirección en la función se destruye todavía veo el valor cambiado fuera

gracias

Answer 1

Conversión de un char* a un std::string:.!

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

Conversión de 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; 

Yo prefiero usar un std::vector<char> en lugar de un verdadero char*; entonces usted no tiene que manejar su 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]; 

Answer 2

Es necesario tener cuidado de cómo manejar la memoria del puntero regrese, por ejemplo, el siguiente código no funcionará porque la memoria asignada en el std: : cadena se lanzará cuando fn() sale.

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

Una solución consiste en asignar la memoria en la función y asegúrese de que la persona que llama de la función libera:

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 usted conoce un límite superior en el tamaño de la cadena que puede crearlo usted mismo en la pila y pasar un puntero, por ej.

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 3

Puede mantener un recolector de basura para su biblioteca implementada como std::vector<char*> g_gc; que es accesible en la biblioteca 'lib'.Más tarde, se puede liberar a todos los punteros en g_gc a su conveniencia llamando 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; 
} 

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 único de rosca, se puede mantener esta g_gc estática. El modelo de subprocesos múltiples implicaría bloquearlo/desbloquearlo.