[debutant] pointeur de pointeur

Version imprimable

13/10/2006, 00h14
bubu92

[debutant] pointeur de pointeur

Bonjour a tous,
j'ai essayé de trouver des infos avec google mais je n'ai trouver que des
exemples compliqués...
Est ce que l'un d'entre vous pourrait m'expliquer brievement, l'interêt d'utiliser
des pointeurs de pointeurs ?
J'ai compris le principe mais pas l'utilité, pourtant j'imagine bien qu'il doit y en
avoir une.
Merci.
13/10/2006, 00h27
Higestromm

Par exemple tu as un tableau (un pointeur) qui contient des pointeurs d'objets assez lourd à copier. Si tu souhaite faire un tris de ces données, il est plus rapide de trier des pointeurs que des objets.

Bon c'est un exemple comme ca mais il doit y en avoir des autres. L'utilisation de pointeur est de toute maniere souvent lié à un gain de performance.

Salut,

Les pointeurs de pointeurs sont, entre autres, particulièrement utiles lorsque tu souhaites passer un pointeur en argument à une fonction (peu conseillé) et que tu souhaites que le pointeur passé soit réellement modifié en sortie de la fonction...

Quelques exemples académiques, qui sont loin, comme tout exemple purement académique, d'être pleinement efficaces ;)

Soit une fonction void plus5(int* nombre) qui permet d'obtenir, apres exécution, la valeur du nombre introduit en argument additionnée de 5 (ici, c'est un pointeur, tu l'auras remarqué ;))
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 void plus5(int* nombre) { *nombre+=5; //ajoute 5 à ce qui est pointé par nombre } //l'appel sous la forme de void mafonct() { int i=2;//déclaration d'un entier de valeur 2 plus5(&i);//appel de la fonction en fournissant "l'adresse de i"(c'est // à dire un pointeur sur i) //ici, i vaut 7 }
soit une fonction prenant bool alloue(int** pptr,int n)un pointeur de pointeur en argument et allouant n entier au pointeur (et renvoyant un booléen pour la réussite)
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 bool alloue(int** pptr, int n) { int *ptempo; ptempo=new int(n);//allocation d'un pointeur contenant n entiers; if(ptempo==NULL) //l'allocation a échoué (on aurait du faire un bloc try catch return false; //on renvoi donc false sans modifier le pointeur delete *pptr; //libération de ce qui est pointé par pptr (c'est à dire d'un //pointeur... devrait etre delete[] si on avait affaire à un //pointeur contenant déjà plusieurs entiers) //le contenu pointé par le pointeur de pointeur est perdu ;) *pptr=ptempo;//ce qui est pointé par pptr recoit le pointeur ptempo return true; } void mafonct() { int *pint=new int;//allocation d'un entier à un pointeur d'entier bool ok=alloue(&pint,4);//appel de alloue avec l'adresse de pint (c'est à dire //un pointeur de pointeur) et récupération du résultat //renvoyé par la fonction if(ok==true) { //l'allocation a réussi, pint dispose de quatre entier (forts semblable à un tableau) } else { //l'allocation a échoué, pint ne dispose toujours que d'un seul entier } }
Aucun des deux codes n'es réellement efficace, ni meme tout à fait correct...

En effet, un bloc try catch serait beaucoup plus adapté à la tentative d'allocation de ptempo, et, en plus, on perd les valeurs du pointeur libéré...

C'est surtout de manière à te montrer comment, en utilisant "ce qui est pointé par" un pointeur, on peut modifier la valeur d'une variable, et en utilisant "ce qui est pointé par un pointeur de pointeur", on peut modifier un pointeur...

Pour rappel, un pointeur est une variable spéciale qui contient "l'adresse à laquelle se trouve une valeur", et un pointeur de pointeur est un pointeur spécial qui contient "l'adresse à laquelle on trouvera un pointeur" (autrement dit "l'adresse à laquelle on trouvera une adresse à laquelle on trouvera une valeur":P )

13/10/2006, 10h33
Médinoc

Code:

*nombre+=5; //ajoute 5 à ce qui est pointé par nombre

Attention avec ce genre de construction sans parenthèses: Je crois bien que ça marche avec les opérateurs d'affectation comme = ou +=, mais si on mettait ++ à la place, on aurait une surprise...
13/10/2006, 12h38
bubu92
Merci pour votre aide ;)
Afin de verifier si j'ai bien tout compris, j'ai ecrit ceci :
Code:

1 2 3 4 5 6 7 8 9 void Fn1 (int **pptr) { int *a = new int; *pptr = &a } int b = 1; int *toto = &b; Fn1 (&toto);
est-ce que j'ai bon ?

Citation:

Attention avec ce genre de construction sans parenthèses: Je crois bien que ça marche avec les opérateurs d'affectation comme = ou +=, mais si on mettait ++ à la place, on aurait une surprise...

J'aurais bien aimé savoir ou mettre les parentheses dans ce cas. Parce que je
vois pas pourquoi ça marcherait pas. Merci a tous.
13/10/2006, 13h07
telliam

presque, j'ai modifié ton code :

Citation:

void Fn1 (int **pptr)
{
int *a = new int;
*pptr = a; /*ici tu vx, je suppose, récupérer l'addresse de la zone alloué, donc c'est a qui faut stocker dans *pptr,
sinon tu vas stocker dans *pptr l'adresse de la variable a, donc une adresse en pile*/
}

int b = 1;
int *toto = &b;
Fn1 (&toto);
13/10/2006, 15h40
Higestromm

A savoir aussi (mais c'est plus valable en C) qu'un pointeur de pointeur peux egalement désigner un tableau de chaine de caractère.

L'exemple courrant est la fonction :

int main(int argc, char **argv);

ici argv est un tableau de chaine de caractère de longueur argc.
13/10/2006, 16h18
koala01
Citation:

Envoyé par Higestromm

A savoir aussi (mais c'est plus valable en C) qu'un pointeur de pointeur peux egalement désigner un tableau de chaine de caractère.

L'exemple courrant est la fonction :

int main(int argc, char **argv);

ici argv est un tableau de chaine de caractère de longueur argc.

Et meme, en allant plus loin, un pointeur de pointeur peut désigner un tableau de pointeur, tout simplement et quel que soit le type utilise...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 int **mat; mat=new *int[10]; for(int i=0;i<10:i++) { mat[i]=new int[10]; } //la libération qui va bien for(int i=0;i<10:i++) { delete[] mat[i]; } delete[] mat;
est tout à fait valide, et fournit un équivalent à une matrice (ici de 10/10)...

Mais, personnellement, je n'aime pas du tout ce genre de codage :P

Pour ce genre d'allocation, je serais plutôt du genre à utiliser une allocation par dimension:

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
int ** AllocMatriceInt(size_t dimX, size_t dimY)
{
	int **ppRet = new int*[dimX];
	int *pMat = new int[dimX*dimY];
 
	for(size_t x=0 ; x<dimX ; x++)
	{
		ppRet[x] = pMat + (x*dimY);
	}
	return ppRet;
}
 
void FreeMatriceInt(int **ppFree)
{
	free(*ppFree);
	free(ppFree);
}
 
//Variante C++ : Met le pointeur à NULL après avoir libéré la mémoire
void FreeMatriceInt(int ** &ppFree)
{
	free(*ppFree);
	free(ppFree);
	ppFree = NULL;
}

14/10/2006, 00h52
bubu92

Je comprends pas les "**" avant "AllocMatriceInt" mais ça doit etre parce
que j'ai pas encore apris ça :) . En tout cas merci pour toute ces infos tres
instructives.

int ** signifie "pointeur vers pointeur vers int".
Mais dans le cas précis, chaque étoile est utilisé en tant que "pointeur vers le premier élément d'un tableau", ce qui donne : "pointeur vers le premier pointeur d'un tableau de pointeurs vers le premier int d'un tableau"

En clair, c'est plus ou mons un tableau de tableaux de int, sauf que les "tableaux" pointés sont en fait différentes parties d'une même zone mémoire.

Et ça s'utilise très simplement:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 //Déclaration int ** tab = NULL; //Allocation tab = AllocMatriceInt(5, 3); //On fait des trucs avec tab[0][0] = 42; tab[2][1] = 0; tab[4][2] = 43; //... //Destruction FreeMatriceInt(tab);