Comment retourner un tableau de caractères à partir d’une fonction?

J’ai essayé ce qui suit:

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

    Meilleur comme paramètre de sortie:

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

    Appelé avec

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

    Vous devez réaliser que char[10] est identique à char* . Vous retournez en fait un pointeur. Le pointeur pointe maintenant sur une variable ( str ) qui est détruite dès que vous quittez la fonction. Le pointeur pointe donc sur … rien!

    Habituellement, en C, vous allouez explicitement de la mémoire dans ce cas, qui ne sera pas détruite à la fin de la fonction:

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

    Soyez conscient cependant! La mémoire pointée par str n’est JAMAIS détruite. Ceci est connu comme une «fuite de mémoire». Assurez-vous de free() la mémoire une fois que vous avez fini:

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

    Comme vous utilisez C ++, vous pouvez utiliser std::ssortingng .

    un tableau de caractères est renvoyé par char *, mais la fonction que vous avez écrite ne fonctionne pas car vous retournez une variable automatique qui disparaît à la fermeture de la fonction. Utilisez quelque chose comme ceci:

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

    Ceci bien sûr si vous retournez un tableau dans le sens C, pas un std :: ou un boost :: ou autre chose. Comme indiqué dans la section commentaire, n’oubliez pas de libérer la mémoire de l’appelant.

    Avec boost:

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

    Un caractère normal char[10] (ou tout autre tableau) ne peut pas être retourné par une fonction.

    Lorsque vous créez des variables locales dans la fonction qui sont créées dans la stack, il est probable que la mémoire soit écrasée lorsque vous quittez la fonction. donc un code comme celui-ci dans la plupart des implémentations c ++ ne fonctionnera pas:

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

    un correctif consiste à créer la variable qui doit être renseignée en dehors de la fonction ou à utiliser, puis à la passer en tant que paramètre et à manipuler une fonction, par exemple:

     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 } 

    Solution c ++ 11 utilisant std :: move (ch) pour transtyper lvalues ​​en rvalues

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

    ou cette option dans 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; }