Fonction retournant l’adresse de la variable locale en C

J’ai le code suivant:

char* gen() { char out[256]; sprintf(out, ...); // you don't need to know what's in here I don't think return out; } 

Et je reçois cette erreur lorsque j’essaie de comstackr:

 ERROR: function returns address of local variable 

J’ai essayé d’avoir ce personnage retour char[] et personnage sans succès. Est-ce que je manque quelque chose?

Votre tableau de caractères out n’existe que dans le corps de la fonction.
Lorsque vous revenez de la fonction, le contenu de out mémoire tampon externe n’est plus accessible, il est simplement local à la fonction.

Si vous souhaitez renvoyer une chaîne de votre fonction à l’appelant, vous pouvez allouer cette chaîne de manière dynamic dans la fonction (par exemple, à l’aide de malloc() ) et renvoyer un pointeur sur cette chaîne à l’appelant, par exemple

 char* gen(void) { char out[256]; sprintf(out, ...); /* * This does NOT work, since "out" is local to the function. * * return out; */ /* Dynamically allocate the ssortingng */ char* result = malloc(strlen(out) + 1) /* +1 for terminating NUL */ /* Deep-copy the ssortingng from temporary buffer to return value buffer */ strcpy(result, out); /* Return the pointer to the dynamically allocated buffer */ return result; /* NOTE: The caller must FREE this memory using free(). */ } 

Une autre option plus simple consisterait à passer le pointeur de mémoire tampon de out tant que paramètre char* , avec une taille de mémoire tampon (pour éviter les dépassements de mémoire tampon).

Dans ce cas, votre fonction peut directement formater la chaîne dans le tampon de destination passé en paramètre:

 /* Pass destination buffer pointer and buffer size */ void gen(char* out, size_t out_size) { /* Directly write into caller supplied buffer. * Note: Use a "safe" function like snprintf(), to avoid buffer overruns. */ snprintf(out, out_size, ...); ... } 

Notez que vous avez explicitement indiqué “C” dans le titre de votre question, mais que vous avez ajouté une balise [c++] . Si vous pouvez utiliser C ++, la chose la plus simple à faire est d’utiliser une classe de chaîne comme std::ssortingng (et de la laisser gérer toute l’allocation / nettoyage de mémoire tampon de chaîne).

Lorsque vous utilisez la déclaration suivante dans la fonction char out[256]; l’espace alloué sera libéré une fois la fonction retournée. Il est donc inutile de renvoyer un pointeur sur le tableau de caractères char .

Si vous voulez renvoyer un pointeur sur une chaîne créée dans la fonction, vous devez utiliser malloc() comme dans

 char* out = (char*)malloc(256*sizeof(char)); 

qui alloue de la place pour 256 caractères mais doit être libéré manuellement à un moment donné avec la fonction free() .

Ou, comme suggéré dans le commentaire de Brian Bi, passez un caractère char * qui pointe vers la chaîne que vous souhaitez utiliser comme argument de votre fonction.

Le problème est que lorsque la fonction gen renvoie (sort), ses variables locales (telles que out ) sont hors de scope et ne sont plus accessibles à l’appelant. Ainsi, lorsque vous revenez out vous renvoyez un pointeur en mémoire qui n’est plus alloué.

Il existe deux options pour “retourner” un pointeur / tampon à partir d’une fonction:

  1. Allouez le tampon dans la fonction appelante et transmettez-le à gen :

     char out[256]; gen(out, sizeof out); 

    il est commun de fournir également la taille de la mémoire tampon que vous transmettez, car la fonction appelée ne peut pas le savoir. Cela signifie que vous devez modifier la déclaration de gen en:

     void gen(char * out, size_t size){ 

    Vous pouvez également coder en dur la taille du tampon entrant à 256 (puisque vous l’avez actuellement dans votre fonction gen ):

     void gen(char out[256]){ 

    Cela signifie que vous devez fournir une variable de type char[256] à gen (et aucun autre pointeur ou tableau). Mais cela vous permet de faire du sizeof out intérieur de gen .

  2. Allouez le tampon dynamicment à l’intérieur de la fonction:

     char * out = malloc(256 * sizeof *out); // ... return out; 

    cela a pour avantage que la déclaration de gen ne change pas. Mais cela signifie que la fonction appelante doit free le tampon renvoyé une fois terminé.