Retour de fonction pour allocation pointeur

Bonjour,

Toujours avec mes pointeurs je me heurte à un nouveau problème. J'ai créé une fonction NewStack() qui créé une pile tout beau tout propre avec le retour de cette pile créé mais après je n'arrive pas à utiliser correctement ce retour dans une autre fonction où je dois déclarer plusieurs piles, dans ce cas, ma fonction IsPalindrome().
J'ai un message erreur de ce type quand j'exécute:
exo.sh(1080,0x7fff74b9b300) malloc: *** error for object 0x7fce01404b68: incorrect checksum for freed object - object was probably modified after being freed.
*** set a breakpoint in malloc_error_break to debug
Abort trap: 6
Je n'ai pas trouvé de solutions, merci bien de vos réponses !

Code:

---

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

Stack NewStack() { int i; Stack new = malloc(sizeof(Stack));   for (i = 0; i < 100; ++i) { new->tab[i] = ' '; } new->summit = -1;   return new; }   int IsPalindrome(char tab[], int size) { Stack first = NewStack(); Stack second = NewStack(); int i; int test;   for (i = 0; i < size; ++i) Push(first, tab[i]); if (size%2 == 0) …… }

---

Ton code est trop expurgé pour un diagnostic complet (manque du code et la définition des types).
Toutefois on peut dire ceci est faux

Code:

---

Stack new = malloc(sizeof(Stack));

---

Ce genre d'expression doit être de la forme suivante pour allouer un objet de type T :

Code:

---

T* p = malloc(sizeof(T));

---

Pardon pour les imprecisions, voici donc ma structure Stack:

Code:

---

1 2 3 4 5 6

struct stack { int summit; char tab[100]; };   typedef struct stack * Stack;

---

puis la fonction Push permettant d'ajouter un char en haut de la pile (Stack):

Code:

---

1 2 3 4 5

void Push(Stack s, char c) { s->tab[s->summit+1] = c; s->summit += 1; }

---

La fonction Pop qui supprime la valeur du haut de la pile et la retourne:

Code:

---

1 2 3 4 5 6 7 8

char Pop(Stack s) { char node; node = s->tab[s->summit]; s->tab[s->summit] = ' '; s->summit -= 1; return node; }

---

et enfin la fonction IsPalindrome en entier pour vérifier si le tableau de char reçu en paramètre est un palindrome:

Code:

---

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 31 32 33 34 35 36 37 38 39 40 41

int IsPalindrome(char tab[], int size) { Stack first = NewStack(); Stack second = NewStack(); int i; int test;   for (i = 0; i < size; ++i) Push(first, tab[i]); if (size%2 == 0) { for (i = 0; i < (size/2); ++i) Push(second, Pop(first)); i = 0; while (i < (size/2) && first->tab[i] == second->tab[i]) { j++; i++; } if ( j == (size/2)) return 1; else return 0; } else { for (i = 0; i < ((size - 1)/2); ++i) Push(second, Pop(first)); Pop(first); i = 0; while (i < ((size-1)/2) && first->tab[i] == second->tab[i]) { j++; i++; } if ( j == ((size-1)/2)) return 1; else return 0; } }

---

Je n'ai pas eu l'occasion de tester la fonction isPalindrome car le bug que je rencontre m'en empêche.

Je pense que le problème se situe ici quand je veux déclarer de nouvelles piles:

Code:

---

1 2 3 4

int IsPalindrome(char tab[], int size) { Stack first = NewStack(); Stack second = NewStack();

---

en lien avec la fonction Newstack() qui maintenant a cette forme:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

Stack NewStack() { int i; struct stack * new = malloc(sizeof(struct stack));   for (i = 0; i < 100; ++i) { new->tab[i] = ' '; } new->summit = -1;   return new; }

---

Et bien je ne comprends pas pourquoi mais maintenant cela fonctionne parfaitement avec la combinaison:

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

Stack NewStack() { int i; struct stack * new = malloc(sizeof(struct stack));   for (i = 0; i < 100; ++i) { new->tab[i] = ' '; } new->summit = -1;   return new; }

---

et la déclaration

Code:

---

1 2 3 4

int IsPalindrome(char tab[], int size) { Stack first = NewStack(); Stack second = NewStack();

---

La déclaration des deux nouvelles piles first et second sont-elles donc totalement sécurisées avec la déclaration se trouvant dans la fonction IsPalindrome ?

Citation:

---

La déclaration des deux nouvelles piles first et second sont-elles donc totalement sécurisées avec la déclaration se trouvant dans la fonction IsPalindrome ?

---

Pas de problème. La seule chose à prévoir c'est leur destruction par free() avant de sortir de la fonction.
Par contre, il y a d'autres causes d'insécurité dans le code où on ne vérifie jamais qu'on accède bien au tableau sans sortir de ses bornes (push(), pop()).

Bonjour.

Une petite remarque sémantique. Utiliser le mot clé réservé new (C++ et autres...) comme nom de variable ne me semble pas très heureux. Cela ne change rien en C mais si cette partie de code est utilisée dans le futur dans un projet qui lui est en C++, bonjour les dégâts ;).

Bonjour,

Bien je n'utiliserais plus le mot-clef new à partir de maintenant, ce sera une bonne habitude de prise ou en tout cas une mauvaise de perdue !
Merci du conseil et joyeux réveillon !

Citation:

---

Envoyé par Tenshock

Code:

---

1 2 3 4

for (i = 0; i < 100; ++i) { new->tab[i] = ' '; }

---

---

Bonjour

Autant utiliser les outils déjà tout faits => memset(new->tab, ' ', 100)...;)

Citation:

---

Envoyé par Tenshock

et la déclaration

Code:

---

1 2 3 4 5

int IsPalindrome(char tab[], int size) { Stack first = NewStack(); Stack second = NewStack(); }

---

La déclaration des deux nouvelles piles first et second sont-elles donc totalement sécurisées avec la déclaration se trouvant dans la fonction IsPalindrome ?

---

Je ne comprends pas ce "totalement sécurisé" (surtout que le C ne fait jamais aucun contrôle de quoi que ce soit et que toi tu ne vérifies même pas la réussite du malloc()) mais bon, dans un fonctionnement "normal" de ton code tu déclares deux pointeurs et tu leurs affectes à chacun un retour d'allocation mémoire (présumé réussi) agrémenté d'un petit remplissage de la zone ce qui est au-moins correct d'un point de vue "manière de travailler".

Si maintenant tu veux vraiment travailler de façon "totalement sécurisée" tu devrais alors nommer tes structures "s_xxx" et tes types "t_xxx" ce qui éviterait la confusion possible entre la structure "stack" et le type "Stack" (de là à ce que tu ailles créer en plus une variable "STACK" et bonjour la relecture et l'évolutivité !!!) et surtout éviter de masquer une étoile derrière un nom de type car c'est le meilleur moyen de planter ton code...

Et bien étant en première année d'ingénierie je n'ai pas encore les réflexes pour avoir un code précis à la relecture et notre prof ne nous demandait pas de vérifier si le malloc était réussi car il ne nous en a même pas parlé.
Pour mes prochaines fonctions je vais donc travailler le nommage de mes variables, jusque là il ne nous était pas imposé un cahier des charges précis pour le nom des variables mais je vais de ce pas m'en imposer un, merci pour ces conseils !