Discussion :

[Tenshock]

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 :

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

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)
	……
}

[diogene]

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 :

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

Stack new = malloc(sizeof(Stack));

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

Code :

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

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

[Tenshock]

Pardon pour les imprecisions, voici donc ma structure Stack:

Code :

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

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 :

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

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 :

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

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 :

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

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 :

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

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 :

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

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;
}

[Tenshock]

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

Code :

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

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 :

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

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 ?

[diogene]

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()).

[gerald3d]

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 .

[Sve@r]

Code c :

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

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)...

et la déclaration

Code :

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

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...

[Tenshock]

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 !