petite question sur les pointeurs

Version imprimable

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:

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:

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
}

Code:

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:

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 ! ;)

20/08/2010, 16h55
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).
20/08/2010, 17h15
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:

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; }
Citation:

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.

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:

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 ....

Citation:

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).

Citation:

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.
Citation:
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:

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:

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 ^^

20/08/2010, 22h19
Pouet_forever
Citation:
Envoyé par Krisprolls31

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

Code:

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.