Come posso restituire un array di caratteri da una funzione?

Ho provato il seguente:

char[10] testfunc() { char[10] str; return str; } 

Il migliore come parametro out:

 void testfunc(char* outStr){ char str[10]; for(int i=0; i < 10; ++i){ outStr[i] = str[i]; } } 

Chiamato con

 int main(){ char myStr[10]; testfunc(myStr); // myStr is now filled } 

Dato che stai usando C ++ potresti usare std::string .

Devi capire che char[10] è lo stesso di char* . In effetti stai restituendo un puntatore. Ora il puntatore punta a una variabile ( str ) che viene distrutta non appena si esce dalla funzione, quindi il puntatore punta a … niente!

Solitamente in C, in questo caso si assegna esplicitamente memoria, che non verrà distrutta al termine della funzione:

 char* testfunc() { char* str = malloc(10 * sizeof(char)); return str; } 

Attenzione però! La memoria puntata da str è MAI distrutta. Questo è noto come “perdita di memoria”. Assicurati di free() la memoria dopo aver finito con esso:

 foo = testfunc(); // do something with your foo free(foo); 

Con Boost:

 boost::array testfunc() { boost::array str; return str; } 

Un char[10] normale char[10] (o qualsiasi altro array) non può essere restituito da una funzione.

un char array viene restituito da char *, ma la funzione che hai scritto non funziona perché stai restituendo una variabile automatica che scompare quando la funzione termina. Usa qualcosa del genere:

 char *testfunc() { char* arr = malloc(100); strcpy(arr,"xxxx"); return arr; } 

Questo ovviamente se si restituisce un array nel senso C, non un std :: o boost :: o qualcos’altro. Come indicato nella sezione commenti: ricorda di liberare l’ememory dal chiamante.

quando crei delle variabili locali all’interno della funzione che sono state create nello stack molto probabilmente vengono sovrascritte in memoria quando si esce dalla funzione. quindi il codice come questo nella maggior parte delle implementazioni c ++ non funzionerà:

 char[] pupulateChar() { char* ch = "wonet return me"; return ch; } 

una correzione è creare la variabile che vuole essere popolata al di fuori della funzione o dove si desidera utilizzarla, quindi passarla come parametro e manipolare la funzione, ad esempio:

 void populateChar(char* ch){ strcpy(ch,"fill me will, this will stay",size); // this will work as long it won overflow it. } int main(){ char ch[100]; // reserve memory in stack outside the function populateChar(ch); //populate array } 

soluzione c ++ 11 usando std :: move (ch) per eseguire il cast di lvalues ​​su rvalue

 void populateChar(char* && fillme){ fillme = new char[20]; strcpy(fillme, "this worked for me"); } int main(){ char* ch; populateChar(std::move(ch)); return 0; } 

o questa opzione in c ++ 11:

 char* populateChar(){ char* ch = "test char"; // will change from lvalue to r value return std::move(ch); } int main(){ char* ch = populateChar(); return 0; }