Discussion :

[marime]

Hello,

Je suis entrain de développer un petit logiciel pour afficher en lettre un nombre que l'on aurait rentré en paramétre. J'ai donc fait mon algo mais je rencontre un bon gros segfault que je ne sais pas résoudre.

Je vous présente le projet

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
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
 
int conversionNombre(int nombreFinal)
{
	char *myNumber = toArray(nombreFinal);
	char *motFinal = " ";
	int i = 0;
	if (myNumber[i] == '-')
		myNumber = decalage(myNumber);
	if (my_strlen(myNumber) == 1)
	{
		if (nombreFinal < 0)
			decalageChiffre(&motFinal, "Moins ");
		decalageChiffre(&motFinal, chiffres[(int)myNumber[0] - 48]);
		my_putstr(motFinal);
		my_putchar('\n');
		return 0;
	}
	myNumber = reverseNb(myNumber);
	while (myNumber[i] != '\0')
	{
		if (findChiffreOrNumber(i) == 1)
			traitementNombre(&motFinal, myNumber[i], myNumber[i - 1], i);
		else
			traitementChiffre(&motFinal, myNumber[i], myNumber[i + 1], i);
		i++;
	}
	if (nombreFinal < 0)
		decalageNb(&motFinal, "Moins ");
	my_putstr(motFinal);
	my_putchar('\n');
	motFinal = " ";
	return 0;
}
 
void traitementChiffre(char **motFinal, char current, char previous, int indice)
{
	char *temp = " ";
	if (indice == 0)
	{
		if (previous != '1' && previous != '7' && previous != '9' && current != '0')
		{
			decalageChiffre(motFinal, chiffres[(int)current - 48]);
		}
	}
	else
	{
		if (current != '0')
		{
			if (current != '1')
				decalageChiffre(&temp, chiffres[(int)current - 48]);
			decalageChiffre(&temp, unite[indice - 2]);
			decalageNb(motFinal, temp);
		}
	}
}
 
void traitementNombre(char **motFinal, char current, char next, int indice)
{
	if (current != '1' && current != '0')
	{
		if (next == '1')
			decalageNb(motFinal, " et ");
		decalageNb(motFinal, nb[(int)current - 50]);
	}
	if ((current == '1' || current == '7' || current == '9') && current != '0')
	{
		if (next == '1' && current != '1')
			decalageNb(motFinal, " et ");
		decalageChiffre(motFinal, nbDizaine[(int)next - 48]);
	}
}
 
void decalageChiffre (char **string, char *toAdd)
{
	int i = 0;
	int j = 0;
	int size = my_strlen(*string);
	int sizeAdd = my_strlen(toAdd);
	char * temp = calloc((size + sizeAdd - 2), sizeof(char));
	if (size > 1)
	{
		while (i < size)
		{
			temp[j] = *string[i];
			j++;
			i++;
		}
	}
	i = 0;
	while (toAdd[i] != '\0')
	{
		temp[j] = toAdd[i];
		j++;
		i++;
	}
	//string = realloc(string, my_strlen(temp) + 1 * sizeof(char));
	*string = temp;
	free(temp);
}
 
void decalageNb (char **string, char *toAdd)
{
	int i = 0;
	int j = 0;
	int size = my_strlen(*string);
	int sizeAdd = my_strlen(toAdd);
	char * temp = calloc((size + sizeAdd - 2), sizeof(char));
	while (toAdd[i] != '\0')
	{
		temp[j] = toAdd[i];
		j++;
		i++;
	}
	i = 0;
	if (size > 1)
	{
		while (i < size)
		{
			temp[j] = *string[i];
			j++;
			i++;
		}
	}
	//string = realloc(string, my_strlen(temp) + 1 * sizeof(char));
	*string = temp;
	free(temp);
}

Le principal soucis que je rencontre est que l'adresse mémoire change lorsque l'on passe en paramétre le pointeur de motFinal depuis conversionNombre vers traitementChiffre.

Ce qui fait que lorsque je veux concaténer la chaîne dans "decalageChiffre" je ne retrouve pas ma chaîne.

J'espére que ce que je demande n'est pas trop compliqué et surtout que mon code et mon explication sont assez claire.

Merci d'avance

[Bktero]

Si tu remplaces char *temp = " "; par char temp[1024] = " ";, il se passe quoi ?

je rencontre un bon gros segfault

Quand ça se passe, il faut être capable de trouver la ligne exacte où cela se produit. 3 solutions : des printf() (pas trop bonne idée), un débogueur en pas à pas (bonne idée), un débogueur mémoire tel Valgrind (à vérifier mais devrait donner des indications intéressantes).

[Metalman]

Valgrind indiquera en effet l'instruction qui envoie le segfault.
Donc après il suffit de voir quelle variable "pourrait" segfaulter.

(et vérifier si ça n'est pas un "bus error" qui proviendrait de l'erreur que Bktero montre)

[grim7reaper]

un débogueur mémoire tel Valgrind (à vérifier mais devrait donner des indications intéressantes).

Valgrind n’est pas du tout un « débogueur mémoire » (ce fût le cas à sa création, mais ce n’est plus vrai maintenant).
Valgrind est un framework pour le développement d’outils d’analyse dynamique (par instrumentation binaire en l’occurrence).
À la limite, un des outils de Valgrind (memcheck), peut être considéré comme un « débogueur mémoire ».

Mais quitte à utiliser un outil de ce genre, si le PO à un compilateur récent (clang >= 3.3 ou gcc >= 4.8), autant passer par les versions intégrés de AddressSanitizer.
L’overhead est grandement réduit (x2 contre x20 pour le ralentissement), bien que sur un programme comme celui-là, memcheck devrait être suffisamment rapide.

[diogene]

Bktero souligne l'utilisation erronnée des constructions comme char *temp = " ";. Ce genre de choses réserve 2 bytes, initialisés par le blanc et le '\0', et met l'adresse du premier dans temp. Cette chaine de 2 bytes est NON MODIFIABLE (en contenu comme en longueur). Toute tentative pour la modifier peut aboutir à un plantage.

Dans la fonction decalageNb(), cette construction n'a pas été utilisée et on a une allocation dynamique. Malheureusement, le code se termine mal :

Code :

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

1
2
3
4
5
6
7
8
void decalageNb (char **string, char *toAdd)
{
...
	char * temp = calloc((size + sizeAdd - 2), sizeof(char));
...
	*string = temp;
	free(temp);
}

ce qui revient à renvoyer l'adresse d'une zone mémoire (temp) qui sera détruite la ligne suivante. Cette information est donc inutilisable par le programme appelant cette fonction. Si il l'utilise, on a un plantage dans le meilleur des cas et sinon un comportement indéfini, aléatoire,...