Bonjour, comment comprendre la significations des pointeurs dans ce code ?
 
 
void depiler(PTR PILE *som, ELEMENT *e)
 
/* Specifications externes : la pile p est supposée non vide. */
 
/* Dépilement de la pile dont le sommet est pointé par som. */
 
/* L’´élément dépilé est pointé par *e. */
 
{
 
     PTR PILE s;
 
     *e=( *som) -> info;
 
     s=*som;
 
     *som = (*som) -> dessous;
 
     free(s);
 
}
 
Dites moi ce qui ne va pas dans mon raisonnement : PTR_PILE *som est un pointeur sur un autre pointeur parce qu'on n'a pas écrit PTR_PILE som, vrai ou faux? Deuxièmement, PTR_PILE sommet est en dehors de la fonction de dépilement une variable de type pointeur sur structure. donc pour le passer en argument formel on a pas besoin de faire PTR_PILE *som mais juste PTR_PILE som, pareil vrai ou faux? Comment passe t'on cette variable (et donc toute variable de type pointeur) en argument effectif? Comment l'écrit-on?
 
Je ne comprend pas ce que veut dire s = *som .
 
dans cette expression s est l'adresse contenue dans le pointeur sur structure PTR_PILE s, donc après cette initialisation cette adresse correspond à *som. Or qu'est-ce que *som? N'est-ce pas l'adresse du pointeur sommet qui pointe lui meme sur le premier maillon de la chaine? Pourquoi on initialise s avec l'adresse du pointeur sommet? A ce moment là quand on va faire free(s), on va détruire l'adresse du pointeur sommet (attention je parle bien de son adresse à lui pas de celle qui est sa valeur)!
 
J'ai du mal aussi avec *som = (*som) -> dessous; si je décortique, *som est l'adresse de l'élément pointé par som donc hors de la fonction il s'agit de l'adresse de sommet. (*som) est donc la valeur de sommet, donc l'adresse du premier maillon et ainsi (*som) -> dessous est le champ dessous du premier maillon, soit l'adresse du prochain élément. Donc pour moi cette expression signifie qu'on remplace l'adresse contenue par le pointeur som du pointeur sommet avec l'adresse du deuxième élément, donc som pointe maintenant sur le deuxième élément. Donc après le free on a plus de pointeur sommet pointant sur un premier élément, mais un pointeur som sur le deuxième élément. Est-ce exact?
 
 

Bonjour,
 

 
Il faudrait voir la déclaration de PTR_PILE mais avec le préfixe PTR, oui on
peut supposer que c'est déjà un pointeur.
 

 
Tout dépend de ce que l'on veut faire. Ici on veut dépiler donc modifier le
pointeur de sommet de pile pour qu'il pointe sur l'élément suivant donc il faut
bien un pointeur de pointeur pour pouvoir modifier sa valeur (la valeur du
pointeur, donc l'adresse pointée) à l'intérieur de la fonction.
 

 
Je n'ai pas compris la question.
 
 

 
s est de type PTR_PILE donc on le fait pointer sur le premier élément de la pile
car le contenu de som (*som) est un pointeur sur le premier élément de la pile.
 
En fait on sauvegarde l'adresse du premier élément pour pouvoir modifier le
début de la pile et ensuite libérer la mémoire avec free. Si on ne sauvegarde
pas avant de déplacer le pointeur de pile, on perd tout accès au premier élément
et on a une fuite mémoire.
 

 
Quand on manipule des pointeurs, il faut faire des dessins:
 
              |------------|    |-------------|   |------------|
              |element0|    |element1|   |element2|     ....
              |------------|    |-------------|   |------------|
              |     info    |    |     info     |   |     info    |
              | dessous--->| dessous-->| dessous----> ...
              |------------|    |-------------|   |-------------|
                   ^
                   |-----------------------|
                   |                             |
             PTR PILE maPile         s
                   ^
                    |
                    |
                  som
 
 
Bon voilà tout mon talent en ascii. maPile est le pointeur que l'on a à
l'origine et qui pointe sur le premier élément. On passe donc &maPile à la
fonction dépiler qui va placer cela dans som. Donc som pointe sur maPile.
 
s = *som donc s == maPile donc pointe également sur le premier élément.
 
*som = (*som)->dessous équivaut à maPile = maPile->dessous. Donc maPile va
 maintenant pointer sur element1.
 
 
 
              |------------|    |-------------|   |------------|
              |element0|    |element1|   |element2| ....
              |------------|    |-------------|   |------------|
              |     info    |    |     info     |   |     info    |
              | dessous--->| dessous-->| dessous----> ...
              |------------|    |-------------|   |------------|
                   ^                    ^
                    |                     |
                    s                    |
                                          |
                                          |
             PTR PILE maPile--|
                   ^
                    |
                    |
                  som
 
 
 
free(s) libère element0.