Discussion :

[CerbeRGD]

Bonsoir tout le monde,

je viens vous voir car j'ai déjà galéré plusieurs heures sur mon problème.

Pour m'entrainer, je souhaite faire l'implémentation d'une pile sous la forme d'un tableau dynamique qui est vide au départ, et auquel j'alloue juste ce qu'il faut de mémoire à chaque ajout d'un nouvel élément. La mémoire qui n'est plus utilisée est libérée à chaque élément retiré de la liste.

Les sources sont disponibles en fichiers attachés à ce post

Les problèmes que je rencontre :
====================

Premier Problème :
--------------------------
si j'ai une pile s avec des données dans le tableau et que je veux la VALEUR de l'élément du dessus de la pile, comment je fais ? J'ai essayé des trucs du genre :

*stack_top(s)

mais ca me donne toujours une erreur de ce type à la compilation (j'ai ce problème dans stack_afficher):

stack.c:--: attention : dereferencing `void *` pointer
stack.c:--: erreur: utilisation invalide d'expression void

Deuxieme Problème :
------------------------------
Lorsque je veux désallouer la mémoire de s->donnees, est ce que je peux juste faire un :

Code :

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

1
2
 
free(s->donnees)

Ou est-ce qu'il faut que je libère d'abord tous les pointeurs contenus dans s->donnees ?

Code :

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

1
2
3
4
 
for (int i=0 ; i++ ; i < s->taille){
    free(s->donnees[i])
}

Merci d'avance pour votre aide.


Cordialement

[Pacorabanix]

Pour le prermier problème :

Code :

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

void *stack_top(stack s);

Voici le prototype de la fonction stack_top

Donc il retourne un pointeur sur... un void, c'est à dire aucun type précis.

Le compilo ne sait donc pas comment "déréférencer" la valeur pointée, c'est à dire comment interpréter le bout de mémoire pointé. ça pourrait etre un int, un char, une struct...

bref telle quelle l'opération n'a pas de sens.

à la limite :

Code :

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

void * elemDuDessus = stack_top(s);

pour juste récupérer le pointeur.

Mais tu ne peux toujours rien en faire tant que tu ne connais pas le type qui se cache derriere (y'a qqchose dans la FAQ à ce sujet, recherche "void" dans la FAQ C).


Ensuite quand tu connais le type il faut l'indiquer :
par exemple si tu sais que c'est un "int" tu peux faire :

Code :

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

1
2
3
int pointeurSurInt * = NULL;
(...)
pointeurSurInt = stack_top(s);

Là, si je ne me trompe pas , le compilateur fait une conversion implicite (toujours possible depuis void *)

tu peux ensuite déréférencer pointeurSurInt ( *pointeurSurInt ) pour utiliser le int pointé.

int resultat;
....
resultat = 10 + 100 * (*pointeurSurInt) - 3 * 3 * 5;
à adapter pour chaque type.

[CerbeRGD]

Ok, merci pour ta réponse Pacorabanix. J'ai compris mon erreur.

Donc le premier problème est résolu.

Je chercherai plus demain pour le second problème (désallocation d'un tableau de pointeur, ou d'un élément d'un tableau de pointeur).

Bonne nuit,

[diogene]

Deuxieme Problème :
------------------------------
Lorsque je veux désallouer la mémoire de s->donnees, est ce que je peux juste faire un :

Code :

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

1
2
 
free(s->donnees)

Ou est-ce qu'il faut que je libère d'abord tous les pointeurs contenus dans s->donnees ?

Code :

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

1
2
3
4
 
for (int i=0 ; i++ ; i < s->taille){
    free(s->donnees[i])
}

Ca dépend : s->donnees[i] sont des pointeurs. Si les objets pointés ont été obtenus par allocation dynamique, il faut le faire (à moins quune copie de leur adresse soit gardée ailleurs et que la libération soit faite ailleurs), sinon, leur adresse sera perdue lors du free(s->données) et on ne pourra jamais libérer la mémoire.

Dans l'exemple de ton main

Code :

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

1
2
    int a=15;
    stack_push(s, &a);

il ne faut absolument pas le faire : a n'a pas été créé par allocation dynamique.

[CerbeRGD]

Si les objets pointés ont été obtenus par allocation dynamique, il faut le faire

Je ne vois pas exactement ce qu'est un objet obtenu par allocation dynamique. Ca serait quelque chose comme ca ?

Code :

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

1
2
 
type* a=malloc( sizeof(*type) );

En supposant que c'est bien ca un objet alloué dynamiquement, comme je ne peux pas deviner quel sera le type d'objets stocké dans la pile, il me semblerait plus sage d'utiliser :

Code :

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

1
2
3
4
 
for (int i=0 ; i++ ; i< s->taille){
    free(s->donnees[i]);
}

Qu'en pensez vous?

Cordialement

[diogene]

Je ne vois pas exactement ce qu'est un objet obtenu par allocation dynamique. Ca serait quelque chose comme ca ?

Code :

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

type* a=malloc( sizeof(*type) );

En supposant que c'est bien ca un objet alloué dynamiquement, comme je ne peux pas deviner quel sera le type d'objets stocké dans la pile, il me semblerait plus sage d'utiliser :

Code :

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

1
2
3
for (int i=0 ; i++ ; i< s->taille){
    free(s->donnees[i]);
}

C'est bien ça. Ce n'est pas sage du tout de faire ce free dans le doute car si l'objet n'a pas été alloué dynamiquement, le programma plante.
Tu dois décider si tes objets sont alloués dynamiquement ou pas. ça dépend de ton application.
Attention :

Code :

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

1
2
3
type* a=malloc( sizeof(type) );
ou
type* a=malloc(sizeof *a );

[CerbeRGD]

C'est bien ça. Ce n'est pas sage du tout de faire ce free dans le doute car si l'objet n'a pas été alloué dynamiquement, le programma plante.
Tu dois décider si tes objets sont alloués dynamiquement ou pas. ça dépend de ton application.

Ok je vois. Donc une solution serait que, dans le programme qui utilise cette implémentation de pile, on désalloue ou pas les variables contenues dans "s->donnees" (en fonction de si elles sont allouées dynamiquement ou pas). Et que ensuite seulement on désalloue le tableau avec un :

Code :

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

1
2
 
free(s->donnees)

Une dernière chose et je vous laisse tranquille

Je ne suis pas sur d'avoir bien compris ce que tu voulais dire par :

Attention :
type* a=malloc( sizeof(type) );
ou
type* a=malloc(sizeof *a );

Ces deux expressions sont bien équivalentes ?


Merci de ton aide et de ta patience diogene.

[diogene]

Ok je vois. Donc une solution serait que, dans le programme qui utilise cette implémentation de pile, on désalloue ou pas les variables contenues dans "s->donnees" (en fonction de si elles sont allouées dynamiquement ou pas). Et que ensuite seulement on désalloue le tableau ...

Et comment sauras-tu si les objets ont été alloués dynamiquement ou non ?


Les deux lignes de code sont équivalentes mais la seconde est souvent préférée. Je les ai mentionnées comme correction à

Code :

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

type* a=malloc( sizeof(*type) );

[CerbeRGD]

Bonjour,

désolé pour le délai de réponse...

Et comment sauras-tu si les objets ont été alloués dynamiquement ou non ?

Pour illustrer mes suppositions, j'ai écrit des exemples d'utilisation de la pile, avec des commentaires (voir les fichiers attachés).

Es-tu d'accord avec les commentaires que j'ai mis dans les exemples?

[diogene]

Es-tu d'accord avec les commentaires que j'ai mis dans les exemples?

Oui

[CerbeRGD]

Oui

Super, il semblerait que j'ai bien compris .
Merci beaucoup pour ton aide, Diogene. Tu m'as bien aidé à comprendre ces histoires d'allocation dynamique.

Bonne continuation