Discussion :

[oranoutan]

Bonjour,

J'aimerai retourné un tableau depuis une fonction comme ceci mais ça ne semble pas fonctionner :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
char *test()
{
	char *tab[] = 
	{
	"un", 
    	"deux", 
    	"trois"
	};
 
	return *tab;
}

[Médinoc]

Deux erreurs:

• Mauvais type de retour
• Tentative de retourner l'adresse d'une variable locale.

Pour retourner un tableau, pas trente-six solutions:

• Recevoir en paramètre l'adresse du tableau (ou de son premier élément) et le remplir
• Allouer dynamiquement (avec malloc(), quoi) le tableau et retourner son pointeur
• /!\Déconseillé : Retourner une structure contenant un tableau (taille fixe). Mais comme il est déconseillé de retourner directement une structure volumineuse...

[Thierry Chappuis]

Tu ne peux pas retourner un tableau alloué statiquement sur la pile de cette manière. Soit tu fait une allocation dynamique, soit tu passes ton tableau en paramètre.

Pour l'allocation dynamique (ne pas oublier de libérer la mémoire utilisée par le tableau dans la fonction appelante):

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <stdlib.h>
 
#define NB_ELEMS(a) ( sizeof (a) / sizeof *(a) )
 
char const **test(void)
{
	char const *tab[] = {"un", "deux", "trois"};
	char const **p_return = NULL;
 
	p_return = malloc((NB_ELEMS(tab) + 1) * sizeof *p_return);
	if (p_return != NULL)
	{
	    size_t i;
 
	    for (i = 0; i < NB_ELEMS(tab); ++i)
	    {
                p_return[i] = tab[i];
	    }
            p_return[i] = NULL;
	}
 
	return *p_return;
}

Avec passage du tableau en paramètre:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#define NB_ELEMS(a) ( sizeof (a) / sizeof *(a) )
 
char *test(char const *tab_out[], size_t taille)
{
    int rv = 0;
    char const *tab[] = {"un", "deux", "trois"};
 
    if (taille >= NB_ELEMS(tab))
    {
        size_t i;
 
        /* -tc- initialisation du tableau */
        for (i = 0; i < taille; i++)
        {
            tab_out[i] = NULL;
        }
 
        for (i = 0; i < NB_ELEMS(tab); i++)
        {
            tab_out[i] = tab[i];
        }
        rv = i;
    }
 
    return rv;
}

Il est également possible de retourner l'adresse d'un tableau déclaré statique, mais cela peut engendrer certains problèmes.

Thierry

[oranoutan]

Bonjour,

Merci pour les réponses.

>Thierry, ton 1er code renvoie des erreurs à la compilation (gcc) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
test.c:19: erreur: assignment of read-only location
test.c:19: attention : assignment makes integer from pointer without a cast
test.c:21: erreur: assignment of read-only location
test.c:21: attention : assignment makes integer from pointer without a cast
test.c:24: attention : return discards qualifiers from pointer target type

Et le 2éme un warning sur le return :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

test.c:28: attention : return makes pointer from integer without a cast

[oranoutan]

J'ai essayé de corriger le 1er code, es ce que c'est bon ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <stdio.h>
#include <stdlib.h>
 
#define NB_ELEMS(a) ( sizeof (a) / sizeof *(a) )
 
char *test(void)
{
	char *tab[] = {"un", "deux", "trois"};
	char **p_return = NULL;
 
	p_return = malloc((NB_ELEMS(tab) + 1) * sizeof *p_return);
	if (p_return != NULL)
	{
	    size_t i;
 
	    for (i = 0; i < NB_ELEMS(tab); i++)
	    {
                p_return[i] = tab[i];
	    }
            //p_return[i] = NULL;
	}
 
	return *p_return;
}

[Emmanuel Delahaye]

J'ai essayé de corriger le 1er code, es ce que c'est bon ?

Ben non. Tu l'a testé ? J'ai donné une correction. Si tu ne la comprends pas, pose des questions.

[oranoutan]

Merci bien.

Ben j'ai tout compris sauf les const pourquoi on peu pas metre de "char **p_return" au lieu "char const **p_return" ? et pourquoi const si c'est pour allouer dynamiquement ?

[Emmanuel Delahaye]

Pour l'allocation dynamique (ne pas oublier de libérer la mémoire utilisée par le tableau dans la fonction appelante):

Ce code est faux. Attention à bien tester le code avant de le publier...

Ceci fonctionne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
 
#include <stdio.h>
#include <stdlib.h>
 
#define NB_ELEMS(a) ( sizeof (a) / sizeof *(a) )
 
char const **test (void)
{
   char const *tab[] = { "un", "deux", "trois" };
   char const **p_return =  malloc ((NB_ELEMS (tab) + 1) * sizeof *p_return);
   if (p_return != NULL)
   {
      size_t i;
      for (i = 0; i < NB_ELEMS (tab); i++)
      {
         p_return[i] = tab[i];
      }
      p_return[i] = NULL;
   }
 
   return p_return;
}
 
int main (void)
{
   char const **pp = test ();
 
   if (pp != NULL)
   {
      size_t i = 0;
      while (pp[i] != NULL)
      {
         printf ("%u: %s\n", (unsigned) i, pp[i]);
         i++;
      }
      printf ("%u: %s\n", (unsigned) i, pp[i]);
 
      free (pp), pp = NULL;
   }
   return 0;
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
0: un
1: deux
2: trois
3: (null)
 
Press ENTER to continue.

Mais son caractère 'hybride' (tableau dynamique de pointeurs sur des chaines littérales) en fait un objet pas facile à utiliser et peu réaliste... Difficile à cerner pour un débutant à cause des 'const'.

On doit pouvoir faire plus simple pour montrer comment "retourner" un tableau dynamique.

[Trap D]

Euh, Je suis un peu surpris de ton exemple, il est potentiellement dangereux car il peut induire en erreur, il me semble.
Celà ne fonctione que parce que les éléments de tab sont des chaînes de caractères en dur, donc allouées dans des zones hors du code de la fonction (je ne sais pas si je suis très clair là ).

[edit]
PS je viens de lire la fin de ton post, ça m'étonnait aussi un peu.
[/edit]