[debutant][allocation dynamique] Segmentation fault...

Version imprimable

Bonjour, alors voici mon problème et le code qui le crée ;-) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 typedef struct base { char* name; char* filename; } base; void SousSaisie(base **data,int n) { char buffer[50]; int i=0; data=(base**)malloc(n*sizeof(base)); //Le debugger m'indique data!=NULL dc pas de pbs d'alloc for(i=0; i < n; i++) { printf("Nom ? "); scanf("%50s",buffer); data[i]->name=(char*)malloc((strlen(buffer)+1)*sizeof(char)); //--> Problème } }
La deuxième allocation en fonctionne pas, pourquoi ?? Sur un tableau de pointeurs sur des structures, j'ai bien le droit d'écrire

Code:

tab_pointeurs[index]->membre_structure=...

?

Salut,

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void SousSaisie(base **data,int n)
{
  char buffer[50];
  int i=0;
 
  data = (base**) malloc(n*sizeof(base*));
 
  for(i=0; i < n; i++)
    {
      printf("Nom ? ");
      scanf ("%50s", buffer);
      data[i] = (base*) malloc (sizeof (base));
      data[i] -> name=(char*)malloc((strlen(buffer)+1)*sizeof(char));
    }
}

Es-tu sûr de ton coup pour le scanf?
Je ne sais pas si le 50 prend en comptes le zéro terminal.
Il vaut mieux utiliser fgets.

Re: [debutant][allocation dynamique] Segmentation fault...

Citation:
Envoyé par x0r
Bonjour, alors voici mon problème et le code qui le crée ;-) :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 typedef struct base { char* name; char* filename; } base; void SousSaisie(base **data,int n) { char buffer[50]; int i=0; data=(base**)malloc(n*sizeof(base)); //Le debugger m'indique data!=NULL dc pas de pbs d'alloc for(i=0; i < n; i++) { printf("Nom ? "); scanf("%50s",buffer); data[i]->name=(char*)malloc((strlen(buffer)+1)*sizeof(char)); //--> Problème } }
Que cherches tu exactement a faire ? Un tableau de n base ou un tableau de n base*.
Parce que la tu as fait un tableau de n base* (qui eux meme ne sont pas alloue, voir le post de rurouni alex), de plus la valeur de date sera perdu lors du retour a la fonction appelante (passage par valeur).

Citation:
Envoyé par rurouni alex
Salut,
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 void SousSaisie(base **data,int n) { char buffer[50]; int i=0; data = (base**) malloc(n*sizeof(base*)); for(i=0; i < n; i++) { printf("Nom ? "); scanf ("%50s", buffer); data[i] = (base*) malloc (sizeof (base)); data[i] -> name=(char*)malloc((strlen(buffer)+1)*sizeof(char)); } }
Es-tu sûr de ton coup pour le scanf?
Je ne sais pas si le 50 prend en comptes le zéro terminal.
Il vaut mieux utiliser fgets.
La solution proposée est correct sauf que :
1 : En C il n'y a pas de cast sur un pointeur void* ! ( il faut enlever tout les cast des fonctions *alloc)
2 : les fonctions d'allocations dynamiques peuvent échouer. Pour éviter tout problème il convient de tester la valeur de retour
3 : scanf() est à proscrire pour faire une saisie utilisateur, pour la simple et bonne raison que cette fonction n'est pas faite pour ca. Il est fortement conseillé d'utiliser la fonction fgets() :
Code:

1 2 fgets(buffer, sizeof buffer, stdin);
fgets() inclus le '\n' terminal il faut donc penser à l'enlever ( une brève recherche sur ce forum te donnera le code ce cette fonction, sinon l'écrire est un bon exercice ;)).
4 : Ca ne sert à rien d'allouer de la mémoire si on ne copie pas la donnée dedans ;)
5 : sizeof(char) sera toujours égal à 1 ( d'après la norme C ), il n'est pas utile de le préciser mais ca ne gêne en rien ;)

Le code devient alors :
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 void SousSaisie(base **data,int n) { char buffer[50]; int i=0; data = malloc( n * sizeof(base*) ); if(! data) { fprintf(stderr, "Erreur d'allocation mémoire\n"); return; } for(i=0; i < n; i++) { printf("Nom ? "); fgets(buffer, sizeof(buffer), stdin); data[i] = malloc ( sizeof(base) ); if(! data[i]) { fprintf(stderr, "Erreur d'allocation mémoire\n"); return; } data[i] -> name= malloc( strlen(buffer) + 1); if(! data[i] -> name ) { fprintf(stderr, "Erreur d'allocation mémoire\n"); return; } strcpy(data[i] -> name, buffer); } }
Voilà ;)

11/07/2004, 01h33
Nasky

Yabo=Emmanuel ou quoi ? :lol:

Sinon pour le point numéro 5, non ce n'est pas la norme, ça dépend de l'implémentation. Sur les machines 32bits, c'est bien 1, mais il faut que le code soit portable ;)
Pour les casts, les omettre implique obligatoirement l'inclusion du header <stdlib.h> . On peut utiliser les casts, ce n'est pas interdit par le langage C... C'est une nouvelle façon de coder qu'est de les enlever. Enfin le débat avait été clos lors d'un précédent post :D
Bof, voila donc quelques remarques... c'était histoire de poster ;)

Nas'

Citation:

Envoyé par gl

Que cherches tu exactement a faire ? Un tableau de n base ou un tableau de n base*.
Parce que la tu as fait un tableau de n base* (qui eux meme ne sont pas alloue, voir le post de rurouni alex), de plus la valeur de date sera perdu lors du retour a la fonction appelante (passage par valeur).

Bien vu ! En effet ton code ne te permettera pas de faire ceci par exemple :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 int main(void) { base ** p; int i; const int n = 2; SousSaisie(p, n); i = 0; while(i < n) { printf("p[%d]->name : %s\n", i, p[i]->name); i++; } return EXIT_SUCCESS; }
Ce code plante sur le printf (et vu le prototyp de ta fonction je pense que c'est ce que tu veux faire).

Citation:

Envoyé par Nasky

Yabo=Emmanuel ou quoi ? :lol:

Sinon pour le point numéro 5, non ce n'est pas la norme, ça dépend de l'implémentation. Sur les machines 32bits, c'est bien 1, mais il faut que le code soit portable ;)

[Mode doit être confirmé par Emmanuel] Non c'est défini dans la norme. sizeof(char) == 1 et toutes les autres valeurs sont définies en fonction. Il me semble que qu'Emmanuel avait donné un lien sur Dinkumware concernant le sujet mais pas moyen de retrouver ni le poste ni le passage sur Dinkumware. Manu si jamais tu passes par là ;) [/Mode doit être confirmé par Emmanuel]

Citation:

Envoyé par Nasky

Pour les casts, les omettre implique obligatoirement l'inclusion du header <stdlib.h> . On peut utiliser les casts, ce n'est pas interdit par le langage C... C'est une nouvelle façon de coder qu'est de les enlever. Enfin le débat avait été clos lors d'un précédent post :D
Bof, voila donc quelques remarques... c'était histoire de poster ;)

Nas'

Non c'est pas interdit, pourquoi faire simple quand on peut faire compliqué :roll:

11/07/2004, 02h39
Nasky

Le lien vers la doc proposé par Emmanuel se trouve sur son site, non ? :)
J'ai vérifié et sizeof(char) retourne bien 1, quelque soit le système.
Mais un char ne vaut pas forcément 8 bits (1 octet).
Explication ici : http://www.isty-info.uvsq.fr/~rumeau/fclc/fclc008.html#q_5

Nas'
11/07/2004, 03h12
Emmanuel Delahaye

Citation:

Envoyé par Nasky

Sinon pour le point numéro 5, non ce n'est pas la norme, ça dépend de l'implémentation. Sur les machines 32bits, c'est bien 1, mais il faut que le code soit portable ;)

C'est inexact.

Je confirme que la définition du langage C précise que sizeof (char) vaut 1 quelque soit l'implémentation. C'est une unité de comptage de la mémoire. Comme toutes les unités elle vaut 1. Rien de mystérieux.

C'est le nombre de bits qui peut changer selon l'implémentation.

Merci pour toutes vos réponses!
Alors c'est effectivement des sizeof(base*) qu'il faut allouer et pas des sizeof(base) :roll:
Bon alors voici mon code, je vais tout reprendre du début:

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
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
 
#define ATTAQUES 1
#define TECHNIQUES 2
#define MOUVEMENTS 3
 
typedef struct base
{
	char* name;
	char* filename;
} base;
 
typedef struct all_data
{
	base** attaques;
	base** techniques;
	base** mouvements;
	int nbattaques;
	int nbtechniques;
	int nbmouvements;
} all_data;
 
void Saisie(all_data *data, short choix);
void SousSaisie(base **data, int n);
 
int main()
{
	all_data data;
	short choix;
	printf("1.Attaques\n2.Techniques\n3.Mouvements\n? ");
	scanf("%hd",&choix);
	while (choix < 1 || choix > 3)
	{
		printf("? ");
		scanf("%hd",&choix);
	}
	Saisie(&data,choix);
        //VideMemoire(...) //Fait les free() sur ce qui a été alloué
 
void Saisie(all_data *data, short choix)
{
	switch(choix) //TODO: Saisie sécurisée
	{
		case ATTAQUES:
			printf("Nombre d'attaques ? ");
			scanf("%d",&data->nbattaques);
			SousSaisie(data->attaques,data->nbattaques);
			break;
		case TECHNIQUES:
			printf("Nombre de techniques ? ");
			scanf("%d",&data->nbtechniques);
			SousSaisie(data->techniques,data->nbtechniques);
			break;
		case MOUVEMENTS:
			printf("Not Implemented\n");
			break;
		default:
			printf("Program bug...\n");
	}
}
 
void SousSaisie(base **data,int n)
{
	char buffer[50];
	int i=0;
 
	data=(base**)malloc(n*sizeof(base*));
	if (data==NULL)
		fprintf(stderr,"Erreur d'allocation mémoire");		
 
	for(i=0; i < n; i++)
	{
		printf("Nom ? ");
		fgets(buffer,sizeof(buffer),stdin); // Je m'occuperai du \n plus tard ;-)
		data[i]->name=(char*)malloc((strlen(buffer)+1)*sizeof(char));
		if (data[i]->name==NULL)
			fprintf(stderr,"Erreur d'allocation mémoire");
		//Je copierai le buffer une fois que l'allocation fonctionnera		
		//Idem pour data->chemin
	}
}

Ce que je cherche à faire c'est de remplir ma structure all_data !! Du moins dans l'immédiat la partie attaques et techniques.

Je crois que je dois avoir une erreur avec SousSaisie, il faudrait que je lui passe l'adresse de data->attaques ou data->techniques ?
Je trouve que ca commence à faire lourd un base ***data ! Il n'y aurait pas une soution plus élégante ?

11/07/2004, 10h30
Emmanuel Delahaye
Citation:

Envoyé par x0r

Ce que je cherche à faire c'est de remplir ma structure all_data !! Du moins dans l'immédiat la partie attaques et techniques.

Il y a deux façon de modifier la valeur d'un objet avec une fonction :
- Retourner une valeur
  
  Code:
  
  int x = f();
- Passer l'adresse
  Code:
  
  1 2 int x; f(&x);
Si l'objet est un pointeur, la regle est la même :
- Retourner une valeur
  
  Code:
  
  int *px = f();
- Passer l'adresse
  Code:
  
  1 2 int *px; f(&px);
  Il n'y a aucune chance de modifier l'entier en faisant ceci:
  Code:
  
  1 2 int x; f(x);
  De même, il n'y a aucune chance de modifier le pointeur en faisant cela:
  Code:
  
  1 2 int *px; f(px);
11/07/2004, 10h37
gl

Citation:

Envoyé par Yabo

1 : En C il n'y a pas de cast sur un pointeur void* ! ( il faut enlever tout les cast des fonctions *alloc)

[mode pinaillage sur les termes]
Non, il peut y avoir des cast sur un pointeur void* en C, ce n'est pas obligatoire c'est tout.
Et non il ne faut pas enlever les cast des fonctions *alloc, mais on peut enlever les cast.
Le code avec ou sans cast est aussi valide (a condition bien sur de tester le retour, d'inclure les entete necessaires, etc..), apres certains estiment qu'il est preferable de ne pas les mettre, d'autre que si et chacun a des arguments valables.
[/mode pinaillage]
11/07/2004, 16h37
Yabo

Citation:

Envoyé par gl

[mode pinaillage sur les termes]
Non, il peut y avoir des cast sur un pointeur void* en C, ce n'est pas obligatoire c'est tout.
Et non il ne faut pas enlever les cast des fonctions *alloc, mais on peut enlever les cast.
Le code avec ou sans cast est aussi valide (a condition bien sur de tester le retour, d'inclure les entete necessaires, etc..), apres certains estiment qu'il est preferable de ne pas les mettre, d'autre que si et chacun a des arguments valables.
[/mode pinaillage]

Je suis tout a fait d'accord j'ai pris le mauvais ton dans mon poste ( j'essaie de faire attention pourtant :roll:). Donc je reformule ;)

1 : Le C standard permet de ne pas mettre de cast sur les pointeurs void*. Le cast sur les fonctions *alloc n'est donc pas obligatoire.

;)
11/07/2004, 18h27
Emmanuel Delahaye

Citation:

Envoyé par Yabo

1 : Le C standard permet de ne pas mettre de cast sur les pointeurs void*. Le cast sur les fonctions *alloc n'est donc pas obligatoire.

Voilà!
13/07/2004, 15h41
x0r

C'est bon mon problème est résolu !
L'erreur était toute bête en plus:
J'ai fait un malloc pour mes base** et pour les base* mais je n'avais pas fait de malloc pour mes base !! Il me manquait un data[i]=malloc(sizeof(base))

Merci pour votre aide