Discussion :

[bubu92]

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.

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

[koala01]

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 :

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

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 :

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

[Médinoc]

Code :

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

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

[bubu92]

Merci pour votre aide
Afin de verifier si j'ai bien tout compris, j'ai ecrit ceci :

Code :

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

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 ?

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.

[telliam]

presque, j'ai modifié ton code :

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