tableau de pointeurs void

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 :

Citation:

---

*stack_top(s)

---

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

Citation:

---

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:

---

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:

---

1 2 3 4

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

---

Merci d'avance pour votre aide.


Cordialement

Pour le prermier problème :

Code:

---

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:

---

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:

---

1 2 3

int pointeurSurInt * = NULL; (...) pointeurSurInt = stack_top(s);

---

Là, si je ne me trompe pas :D, 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.

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,

Citation:

---

Envoyé par CerbeRGD

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

Code:

---

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:

---

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:

---

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.

Citation:

---

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:

---

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:

---

1 2 3 4

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

---

Qu'en pensez vous?

Cordialement

Citation:

---

Envoyé par CerbeRGD

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

Code:

---

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:

---

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:

---

1 2 3

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

---

Citation:

---

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:

---

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 :

Citation:

---

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.

Citation:

---

Envoyé par CerbeRGD

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:

---

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

---

Bonjour,

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

Citation:

---

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?

Citation:

---

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

---

Oui

Citation:

---

Oui

---

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

Bonne continuation