Discussion :

[Krisprolls31]

Bonjour, alors voici ma question:

etant donné un entier m, je veux créer une fonction qui à partir de cet entier me renvoie un tableau de taille m passé en paramètre (de sortie). Pour cela j'utilise des pointeurs , mais deux possibilités me viennent en tête. quelle est la plus "propre" ?

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
 
int main()
{
    int m = 10;
    int* p = malloc(m*sizeof(int));
    if (p == NULL) 
    {
        printf("Memory allocation problem");
        exit(0);
    }
 
    ma_fonction(m, p);
 
    ....
 
    free(p);
    return 0;
}

avec

Code :

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

1
2
3
4
5
6
7
8
 
void ma_fonction(int m, int* p)
{
    int i;
 
    for(i = 0; i < m; i++)
        *(p+i) = i ;   //par exemple
}

ou

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
int main()
{
   int m = 10;
   int* p;
 
   ma_fonction(m, &p);
 
   ....
 
   return 0;
}

avec

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
 
void ma_fonction(int m, int** p)
{
    *p = malloc(m*sizeof(int));
    if (*p == NULL) 
    {
        printf("Memory allocation problem");
        exit(0);
    }
 
    int i;
 
    for(i = 0; i < m; i++)
        *(*p+i) = i ;   //par exemple
}

Merci d'avance pour votre réponse !

[haraelendil]

Au final ça revient au même (sauf peut-être erreurs que je n'ai pas vu^^), mais ça sert à rien de t'embêter à passer un pointeur de pointeur (sauf si tu veux des tableaux à 2dimensions, mais là ce n'est pas la cas).

Donc un code plus simple est plus maintenable, tu devrais prendre la première solution (la plus simple est souvent la meilleure).

[NoIdea]

Il y a tout de même quelque chose qui m'intrigue :
quel est l'utilité de ta fonction. Je m'explique : ta fonction pour l'instant se contente d'allouer de la mémoire pour un tableau de int de taille m et de remplir se tableau avec 0,1,2,3,4,...
Du post que tu as écrits, j'ai crut comprendre que le remplissage par 0,1,2,... n'étais qu'a titre d'exemple.

En résumé : Si tu ne veux pas que ton tableau soit rempli, tu viens de recodé malloc mais prenant 2 paramètres et n'en renvoyant aucun.Si tu veux que le tableau soit rempli, pourquoi n'écris tu pas une fonction qui ressemble à ceci :

Code :

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

1
2
3
4
5
6
7
8
9
int*make_tab(int m)
{
      int*p=malloc(sizeof(int)*m);
      for(int i=0;i<m;i++)
      {
              *(p+i)=i;
      }
      return p;
}

mais ça sert à rien de t'embêter à passer un pointeur de pointeur

Il me semble que si :

si il ne reçois pas un pointeur de pointeur, p ne sera pas passé mais une copie de p (c'est pour sa qu'il existe le passage par référence en c++...)
ainsi, se serait la copie de p qui possèderais la nouvelle valeur(le retour de malloc) et non p;

De plus, la première solution à le défaut de ne pas allouer la mémoire. Cependant, dans cette solution, la mémoire est allouée sans que l'utilisateur le sache ; il ne pensera donc pas a faire un free. Il faut donc créer une fonction destroy_tab.

[Krisprolls31]

en fait je travaille sur un algo de codage/décodage (BCH) et je dois construire plusieurs tableaux au cours de cet algo. un exemple de fonction que j'utilise:

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
 
void generate_gf(int mm, int* pp, int* alpha_to, int* index_of)
/* generate GF(2**mm) from the irreducible polynomial p(X) in pp[0]..pp[mm]
   lookup tables:  index->polynomial form   alpha_to[] contains j=alpha**i;
                   polynomial form -> index form  index_of[j=alpha**i] = i
   alpha=2 is the primitive element of GF(2**mm)
*/
 
// bon on s'en fout un peu du but de cette fonction, mais celle ci construit 
//les deux tableaux alpha_to et index_of utilisés sous forme de pointeurs
 
 {
  int i, mask ;
  int nn = pow(2,mm) -1;
 
  mask = 1 ;
  alpha_to[mm] = 0 ;
  for (i=0; i<mm; i++)
   { alpha_to[i] = mask ;
     index_of[alpha_to[i]] = i ;
     if (pp[i]!=0)
       alpha_to[mm] ^= mask ;
     mask <<= 1 ;
   }
  index_of[alpha_to[mm]] = mm ;
  mask >>= 1 ;
  for (i=mm+1; i<nn; i++)
   { if (alpha_to[i-1] >= mask)
        alpha_to[i] = alpha_to[mm] ^ ((alpha_to[i-1]^mask)<<1) ;
     else alpha_to[i] = alpha_to[i-1]<<1 ;
     index_of[alpha_to[i]] = i ;
   }
  index_of[0] = -1 ;
 }

c'est juste que je ne sais pas si je dois utiliser en paramètre de ma fonction simplement les pointeurs correspondants en ayant prealablement alloué la mémoire avant l'appel de la fonction ou utiliser des pointeurs de pointeurs et allouer la mémoire au sein de la fonction ....

De plus, la première solution à le défaut de ne pas allouer la mémoire.

La mémoire est allouée avant l'appel de la fonction (à moins que tu voulais dire "deuxième solution" , mais là aussi la mémoire est allouée au sein même de la fonction).

Cependant, dans cette solution, la mémoire est allouée sans que l'utilisateur le sache ; il ne pensera donc pas a faire un free. Il faut donc créer une fonction destroy_tab.

Tout à fait d'accord , je me posais d'ailleurs la question.

Si tu ne veux pas que ton tableau soit rempli, tu viens de recodé malloc mais prenant 2 paramètres et n'en renvoyant aucun.Si tu veux que le tableau soit rempli, pourquoi n'écris tu pas une fonction qui ressemble à ceci :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
int*make_tab(int m)
{
      int*p=malloc(sizeof(int)*m);
      for(int i=0;i<m;i++)
      {
              *(p+i)=i;
      }
      return p;
}

je préfère utiliser des fonctions de prototype comme :

Code :

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

1
2
3
4
5
 
void fonction(param_entree, param_sortie)
// ou
int fonction(param_entree, param_sortie)
//pour avoir un code de retour

ça permet de recevoir des infos (flags) pour savoir si tout c'est bien passé. enfin j'ai l'habitude de coder comme ça ^^

[Pouet_forever]

je préfère utiliser des fonctions de prototype comme :

Code :

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

1
2
3
4
5
 
void fonction(param_entree, param_sortie)
// ou
int fonction(param_entree, param_sortie)
//pour avoir un code de retour

Dans ce cas là, tu n'as pas d'autre choix que d'utiliser la seconde forme (passer par un pointeur de pointeur).
Pour renvoyer un code d'erreur, tu peux tester si la fonction malloc renvoie NULL.
Il serait plus idiomatique d'utiliser une forme telle '(*p)[i]' plutôt que '*(*p+i)'.

Pour la fonction pow il vaudrait mieux utiliser une fonction qui travaille uniquement sur des int plutôt que sur des double. Si tu utilises une forme telle que l'exponentiation rapide ça sera plus rapide aussi.

Bon courage.