come copiare char * in una stringa e viceversa

Question

Se si passa un char * in una funzione. Voglio quindi prendere quel char * convertirlo in uno std :: string e una volta ottenuto il risultato converti nuovamente in char * da una stringa: std :: per mostrare il risultato.

1. non so come fare per la conversione (non sto parlando const char *, ma solo char *)
2. Non sono sicuro di come manipolare il valore del puntatore mando in.

così passi ho bisogno di fare

1. prendere in un char *
2. convertirlo in una stringa.
3. prendere il risultato di tale stringa e riportarlo sotto forma di char *
4. restituire il risultato in modo che il valore sia disponibile all'esterno della funzione e non venga distrutto.

Se possibile Posso vedere come potrebbe essere fatto tramite riferimento vs un puntatore (il cui indirizzo passo in termini di valore comunque posso comunque modificare il valore che puntatore sta puntando. Così, anche se la copia del puntatore indirizzo nella funzione viene distrutta continuo a vedere il valore modificato esterno

grazie

Answer 1

Conversione di un char* ad un std::string:.!

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

Conversione di un std::string ad 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; 

Io preferisco usare un std::vector<char> invece di un vero e proprio char*; allora non c'è bisogno di gestire la propria 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

Hai bisogno di guardare come gestire la memoria dal puntatore si torna, per esempio il codice qui sotto non funziona perché la memoria allocata nella std: : la stringa verrà rilasciata quando fn() si chiude.

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

Una soluzione è quella di allocare la memoria nella funzione e assicurarsi che il chiamante della funzione lo rilascia:

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 

In alternativa, se si conosce un limite superiore per la dimensione della stringa puoi crearlo nello stack te stesso e passare un puntatore, ad es

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

È possibile mantenere un garbage collector per la libreria implementato come std::vector<char*> g_gc; che è accessibile nella libreria 'lib'.In seguito, è possibile rilasciare tutti i puntatori in g_gc a vostro piacimento chiamando 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; 
} 

funzione release_garbage sarà simile:

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

In un unico modello filettato, è possibile mantenere questo g_gc statica. Il modello multi-thread implicherebbe il blocco/sblocco.