Je m´interroge sur l´utilité des pointeurs de pointeurs : pourquoi ne pas utiliser un simple pointeur à chaque fois ?

un pointeur de pointeur est un simple pointeur ... vers un autre pointeur.

Lorsqu´une fonction doit modifier un de ses arguments, on lui passe un pointeur vers l´argument pour qu´elle puisse le modifier.

Mais si l´argument à modifier est déjà un pointeur, alors il faut lui passer un pointeur vers le pointeur.

Ca se tiens

En gros c´est pour faire un truc du genre :

void allocation(int **ptr)
{
*ptr = malloc(sizeof int);
}

Tout a fait

ce que tu proposes est valide.

tu peux aussi considérer des tableaux de pointeurs, ou alors un pointeurs (donc finalement un tableau dynamique) qui stocke des adresses (tu auras ainsi encore une double indirection)

regarde mon tuto (cf ma carte)
chapitre E.2.

C´est très utile, notament pour une structure de pile...

utile aussi pour inserer dans des listes chainées.

et j´ai même mieux : les pointeurs de pointeurs ... de pointeurs.

j´ai écrit cette fonction tout à l´heure et j´ai pensé à ce topic donc là voici :

template<class T> void make_matrix(T*** ptr,int m,int n)
{
*ptr=new T*[m];
int i;
for (i=0;i<m;i++)
(*ptr)[i]=new T[n];
}

tu alloues des zones non contigues pour une bete matrice => TOUJOURS des tableaux a 1 dimension ; si vous avez besoin de structures non "rectangulaires" (m*n) ou "parallelepipediques" (m*n*o) etc, encapsulez dans des structures de donnees de plus haut niveau (ie. liste de tableau, tableau de listes, liste de listes, etc.). Vous pourrez pourrez mettre en place des gestions specifiques bien plus efficaces, tout en facilitant l´utilisation.

j´peux faire mieux : j´peux déclarer des pointeurs de pointeurs de pointeurs de pointeurs de pointeurs de pointeurs etc etc ^^

sur une application réel, je suis déjà monté a 5 etoile.
ca devient compliqué a gerer...

arf je n´ai jamais rien compris aux pointeurs. Vous n´auriez pas un cours pour les perdus comme moi ?

celui de jeanyvesyves doit bien expliquer ca...
sinon pour faire simple
un pointeur stocke l´adresse de n´importe quel variable
ainsi en ecrivant a cette adresse la, on ecrit sur la variable dont c´est l´adresse

TYPE var;
TYPE* point = &var;

• point = fghjk;

on a var == fghjk;

deplus si tu as
void fnct (TYPE v)
{
v = fghjk;}

TYPE var = azerty;
fnct (var);
var == azerty;
alors que

void fnct (TYPE* po)
{

• po = fghjk;

}

TYPE var = azerty;
TYPE* point = &var;
fnct (point);
var == fghjk;

cela reponds a ta question.