Discussion :

[vitoubien]

Hello,

Je suis tout juste débutant et mon pitoyable code doit être bourré d'erreurs. pardon d'avance.

Mais voila, après plusieurs tatonnements ce code semble fonctionner à première vue et pourtant quand je décommente la boucle, ça plante sur une "segmentation fault".

Quelqu'un pourrait-il m'aider à comprendre le problème et m'indiquer d'autres erreurs éventuelles. Vive le C, mais qu'est-ce que c'est difficile

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
 
 
	int i, j;
	char **tabchaine;
 
	tabchaine = (char**) malloc(10 * sizeof(char*));
 
	for (i = 0; i < 5; i++)
		tabchaine[i] = (char*) malloc(7 * sizeof(char));
 
//	for (i = 0; i < 10; i++)
//		strcpy(tabchaine[i], "aaaaaa");
 
	strcpy(tabchaine[1], "zzzzz");
 
	for (i = 0; i < 10; i++)
		printf ("tabchaine[%d] : %s\n", i, tabchaine[i]);

Ce n'est pas du tout comme ça qu'on fait ?

[zul]

C'est pas mal, mais tu as du changer la taille de ton tableau à un moment. Tu initialise seulement ton tableau de 0 à 5, et ensuite tu parcours de 0 à 10 (et tu alloue un tableau de 10 éléments donc ça parait cohérent).

Je te conseille d'utiliser un const size_t pour définir la taille de ton tableau une seule fois, et d'utiliser cette variable dans toutes tes boucles, ça évitera ce genre d'erreur.

[ram-0000]

Aller, c'est presque bon, l'erreur est ici :

Code :

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

1
2
3
4
5
	for (i = 0; i < 5; i++)
		tabchaine[i] = (char*) malloc(7 * sizeof(char));
 
	for (i = 0; i < 10; i++)
		strcpy(tabchaine[i], "aaaaaa");

Tu alloues 5 chaines de 7 caractères dans ton tableau et tu en écrit 10

Il faudrait utiliser les constantes pour supprimer ce genre d'erreur

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
 
#define SIZE_ARRAY 10
#define LEN_STRING 7
 
	int i, j;
	char **tabchaine;
 
	tabchaine = (char**) malloc(SIZE_ARRAY * sizeof(char*));
 
	for (i = 0; i < SIZE_ARRAY; i++)
		tabchaine[i] = (char*) malloc(LEN_STRING * sizeof(char));
 
	for (i = 0; i < SIZE_ARRAY; i++)
		strcpy(tabchaine[i], "aaaaaa");
 
	strcpy(tabchaine[1], "zzzzz");
 
	for (i = 0; i < SIZE_ARRAY; i++)
		printf ("tabchaine[%d] : %s\n", i, tabchaine[i]);

Attention tu n'alloure que 7 octets pour ta chaine de caractères (donc 6 caractères + \0).

Lorsque tu fais le strcpy(tabchaine[i], "aaaaaa"), tu es dangereusement proche de la limite.

[Edit] Grilled mais dans la même minute

[vitoubien]

Merci !

[vitoubien]

Euh pour confirmation, pas de problème avec les casts, ni mes sizeof ?
Mon compilateur sous Kdevelop me parait très permissif sur ces questions.

Et je ne suis pas sûr d'avoir encore bien compris la logique.

[vitoubien]

Autres questions de base et j'en aurai fini pour le moment:

1/ Ai-je le droit de réallouer un seul emplacement de cette façon:

Code :

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

1
2
3
4
5
6
 
	realloc(tabchaine[4], 16 * sizeof(char));
	strcpy(tabchaine[4], "123451234512345");
...
	for (i = 0; i < 10; i++)
		printf ("tabchaine[%d] : %s\n", i, tabchaine[i]);

Ce qui semble parfaitement fonctionner mais j'ai comme un doute.

2/ Ce code fonctionnerait-il si j'avais utilisé calloc au lieu de malloc pour l'initialisation ?
Là aussi, il semble que oui mais j'ai qd même un gros doute.

[ram-0000]

Autres questions de base et j'en aurai fini pour le moment:

1/ Ai-je le droit de réallouer un seul emplacement de cette façon:

realloc(tabchaine[4], 16 * sizeof(char));
strcpy(tabchaine[4], "123451234512345");
...
for (i = 0; i < 10; i++)
printf ("tabchaine[%d] : %s\n", i, tabchaine[i]);

Ce qui semble parfaitement fonctionner mais j'ai comme un doute.

Oui, c'est tout bon

realloc essaye d'agrandir le bloc mémoire précédemment alloué par malloc ou realloc. S'il n'y a pas assez de place pour agrandir, il alloue un nouveau bloc, copie l'ancien bloc dans le nouveau bloc et libère l'ancien bloc.

2/ Ce code fonctionnerait-il si j'avais utilisé calloc au lieu de malloc pour l'initialisation ?
Là aussi, il semble que oui mais j'ai qd même un gros doute.

Je ne sais pas, je n'utilise jamais calloc (mais c'est une habitude personnelle)

[vitoubien]

Merci beaucoup ram-0000 pour ta patience et tes éclaircissements,

Je crois avoir compris une bonne chose bien basique. Si ce n'est peut-être un oubli dans le realloc. La ligne devrait être, je crois:
tabchaine[4] = realloc(tabchaine[4], 16 * sizeof(char));
et non simplement:
realloc(tabchaine[4], 16 * sizeof(char));

-----------------------------

Mais puis-je abuser encore un peu en te soumettant ce code ?
J'ai besoin de faire mes armes en autodidacte sur ces problèmes d'allocation mémoire et de pointeurs.

Je ne comprends pas pourquoi ce premier code fonctionne...

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define SIZE_ARRAY 10
#define LEN_STRING 7
 
 
void allocation (char** chaine, int taille, int longueur)
{
	int i;
	for (i = 0; i < taille; i++)
		chaine[i] = (char*) malloc(longueur * sizeof(char));
}
 
int main(int argc, char *argv[])
{
	char** tabchaine;
	int i;
 
	tabchaine = (char**) malloc(SIZE_ARRAY * sizeof(char*));
	allocation(tabchaine, SIZE_ARRAY, LEN_STRING);
 
	for (i = 0; i < SIZE_ARRAY; i++)
		strcpy(tabchaine[i], "aaaaaa");
 
	for (i = 0; i < SIZE_ARRAY; i++)
		printf ("tabchaine[%d] : %s\n", i, tabchaine[i]);
 
 
  return EXIT_SUCCESS;
}

... et cette variante plante sur une erreur de segmentation (une fois de plus).

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
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define SIZE_ARRAY 10
#define LEN_STRING 7
 
void allocation2 (char* chaine, int longueur)
{
	chaine = (char*) malloc(longueur * sizeof(char));
}
 
int main(int argc, char *argv[])
{
	char** tabchaine;
	int i;
 
	tabchaine = (char**) malloc(SIZE_ARRAY * sizeof(char*));
 
	for (i = 0; i < SIZE_ARRAY; i++)
		allocation2(tabchaine[i], LEN_STRING);
 
 
	for (i = 0; i < SIZE_ARRAY; i++)
		strcpy(tabchaine[i], "aaaaaa");
 
	for (i = 0; i < SIZE_ARRAY; i++)
		printf ("tabchaine[%d] : %s\n", i, tabchaine[i]);
 
 
  return EXIT_SUCCESS;
}

[zul]

3 choses :
- en C, tu n'a pas besoin de caster les retours de malloc / realloc (et ça peut cacher une erreur).

- Generalement, il faut utiliser realloc de la façon suivante (pour gérer les cas d'erreur.

Code :

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

1
2
3
4
5
6
7
8
9
 
char * tmp;
tmp = realloc(myTruc, myNewSize);
if (tmp == NULL) {// impossible de trouver de la mémoire pour réallouer
  free(myTruc);
  return noEnoughMemory;
} else {
  myTruc = tmp;
}

- Enfin en dernier point, pour modifier un objet dans une fonction C, il faut passer un pointeur sur cet objet. En l'occurence dans ta fonction allocation2, tu essaye de modifier chaine (à savoir un pointeur sur char*). Pour réussir à faire cette modfication, il faut passer un char**. Ça donnerait

Code :

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

1
2
3
4
5
 
void allocation2 (char** chaine, size_t longueur)
{
        *chaine = malloc(longueur);
}

De plus, (mais je vais finir par te perdre, sizeof(char) == 1 par definition, donc on peut l'oublier, et pour décrire une longueur, on utilise généralement le type size_t qui a été pensé à cet effet. Il reste encore à gérer le cas d'erreur où malloc pourrait retourner NULL.

[vitoubien]

super zul, ça marche.

Ne me reste plus ce jour qu'à méditer là-dessus mais je pense que ça va rentrer.

Bon je clos le sujet grâce à toi.

[wadabush]

Si je peux me faire mettre , je pense que c'est une tres mauvaise habitude d'oublier le sizeof(char), meme si ca fait 1, parce que ca pourrait bien dependre des differentes plateformes...

[zul]

Si sizeof(char) != 1, ce n'est pas du C, c'est quelquechose qui ressemble à du C peut-être, mais le standard impose sizeof(char) == 1 (6.5.3.4 constraints 2).

[vitoubien]

Ah si ! Une dernière question (enfin... des promesses toujours des promesses), et c'est la résolution du dernier problème qui m'y fait penser.

Ces deux codes fonctionnent apparemment. Mais quelle est la différence sémantique entre les deux s'il y en a une ?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void affecte (char* chaine, char* chaine2)
{
	strcpy(chaine, chaine2);
}
 
...
 
	for (i = 0; i < SIZE_ARRAY; i++)
		affecte(tabchaine[i], "aaaaaa");

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void affecte (char** chaine, char* chaine2)
{
	strcpy(*chaine, chaine2);
}
 
...
 
	for (i = 0; i < SIZE_ARRAY; i++)
		affecte(&tabchaine[i], "aaaaaa");

[wadabush]

@Zul: Ok pour le sizeof(char) qui est egal a 1 en C. Cela dit, pour des raisons de compatibilite, je ne dirais pas que le sizeof est inutile.

[vitoubien]

Et the bouquet final (logique) mais qui se finit évidemment en segmentaion fault:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void allocation3 (char*** chaine, int taille, size_t longueur)
{
	int i;
	*chaine = malloc(taille * sizeof(char*));
	for (i = 0; i < taille; i++)
		*chaine[i] = malloc(longueur);
}
 
...
 
	char** tabchaine;
 
	allocation3(&tabchaine, SIZE_ARRAY, LEN_STRING);

J'ai l'impression d'avoir tout essayé mais ça veut pas.
C'est la boucle dans la fonction qui me parait déconner mais j'ignore pourquoi.
<soupir>

[diogene]

C'est un problème de priorité des opérateurs :

Code :

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

(*chaine)[i] = malloc(longueur);

[wadabush]

Ton probleme est dans les parentheses:

Code :

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

1
2
3
4
5
6
7
8
9
 
 
void allocation3 (char*** chaine, int taille, size_t longueur)
{
	int i;
	*chaine = malloc(taille * sizeof(char*));
	for (i = 0; i < taille; i++)
		(*chaine)[i] = malloc(longueur);
}

Essaye ca, ca devrait passer.
Le probleme est que tu dereferencais la zone de memoire chaine + 1 (qui ne correspondait a rien), et que tu allouais la memoire avec malloc.

Avec les parantheses, tu accedes a l'element 1 (le deuxieme du tableau) apres avoir dereference le pointeur.

[Edit]: Une fois de plus, je fus eu...

[wadabush]

Ah si ! Une dernière question (enfin... des promesses toujours des promesses), et c'est la résolution du dernier problème qui m'y fait penser.

Ces deux codes fonctionnent apparemment. Mais quelle est la différence sémantique entre les deux s'il y en a une ?

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void affecte (char* chaine, char* chaine2)
{
	strcpy(chaine, chaine2);
}
 
...
 
	for (i = 0; i < SIZE_ARRAY; i++)
		affecte(tabchaine[i], "aaaaaa");

Code :

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

1
2
3
4
5
6
7
8
9
10
 
void affecte (char** chaine, char* chaine2)
{
	strcpy(*chaine, chaine2);
}
 
...
 
	for (i = 0; i < SIZE_ARRAY; i++)
		affecte(&tabchaine[i], "aaaaaa");

Sinon il n'y a pas de reelle difference entre ces deux bouts de code.
Dans un cas, tu passes l'adresse du premier element de ton tableau (deja alloue) et tu modifies les valeurs, dans l'autre cas, tu passes l'adresse de l'adresse du premier element de ton tableau, et tu dereferences, ce qui revient au meme.
En general, tu n'as pas besoin de passer l'adresse de l'adresse du premier element de ton tableau, sauf dans le cas ou tu veux que ta fonction alloues le tableau (en effet, il faudra que ta fonction soit capable de modifier l'adresse du premier element de ton tableau, impossible si tu la passes en argument).

L'explication est la suivante:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void ma_func(char *test)
{
    test = malloc(sizeof(char) * MY_SIZE);
}
 
void main (void)
{
    char *my_string = NULL;
    ma_func(my_string);
}

Dans ce cas la lorsque tu appelles ma_func, tu copie la valeur de my_string (originellement a l'adresse 0x00000001 (exemple), qui ne contient rien de bien interessant car rien n'est alloue, dans une autre variable (stocke ailleurs en memoire), correspondant a test (0x00000002).
Ensuite tu alloues de la memoire en assignant la valeur au pointeur situe en 0x00000002. Donc 0x00000001 n'a jamais change et quand tu retournes de ta fonction, cela n'a rien change.


Maintenant si j'ecris:

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
void ma_func(char **test)
{
    *test = malloc(sizeof(char) * MY_SIZE);
}
 
void main (void)
{
    char *my_string = NULL;
    ma_func(&my_string);
}

my_string est toujorus a l'adresse 0x00000001, mais je passe l'adresse a laquelle est stocke la valeur de mon pointeur vers my_string (0x00000003, zone memoire ou il y'a ecrit 0x00000001 donc).
Maintenant en appelant la fonction, on copie la valeur de la zone memoire 0x00000003 dans une autre zone memoire comme precedemment (dans 0x00000002). Donc maintenant 0x00000002 contient une valeur interessante qui est l'adresse du tableau. En dereferencant, on est maintenant capable de modifier directement la valeur contenu a la zone memoire 0x00000001.



J'espere avoir ete assez clair. C'est plus facile a expliquer ca avec des dessins

[vitoubien]

Merci à tous, cette fois je pense que je suis assez bien armé pour faire face à pas mal de soucis du genre.

Bonne journée