Discussion :

[grizzlyx]

Bonjour à tous,
J'ai un gros problème d'erreur de segmentation dans mon programme. Pourriez vous m'aider à le trouver et merci beaucoup d'avance à tous ceux qui vont s'intéresser à mon problème. A 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
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
//Structure des produits de la société (fichier.h)
typedef struct l1{
	char nomp[30];
	struct l1 *suivant;
} Elt1;
 
typedef Elt1 *ListeP;
 
 
//Structure de données Société
typedef struct {
//	int clesociete;
	char nom[30];
	char adresse[50];
	ListeP Produits;
} Societe;
 
 
 
 
 
(le fichier .c)
ListeP ajoutP (ListeP prod, char *nm)
{ListeP new=prod;
prod=(ListeP)malloc(sizeof(Elt1));
strcpy(prod->nomp, nm);
prod->suivant = new;
return prod;
}
 
Societe ajoutSociete ()
{
Societe s;
s.Produits=NULL;
printf("Saisissez le nom de la société : ");
scanf("%s",s.nom);
printf("Saisissez l'adresse de la socitété : ");
scanf("%s",s.adresse);
printf("Saisissez le nom du produit : ");
printf("bouh1");
s.Produits = ajoutP(s.Produits, "tondeuse");
printf("bouh2");
printf("%s %s",s.nom,s.adresse);
}
 
main()
{
Societe tmp;
tmp=ajoutSociete();
printf("%s %s %s",tmp.nom,tmp.adresse,tmp.Produits->nomp);
}

[ToTo13]

Bonjour :

Code :

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

ListeP new=prod;

Si tu le faisais après le malloc ???
Et je ne suis pas sûr que tu puisse copier des structures directement.

[grizzlyx]

Je suis vraiment désolé, mais j'avais complètement oublié qu'une fonction devait contenir un return (ajoutSociete dans mon cas) ...
Vraiment désolé ...
Merci encore

[Emmanuel Delahaye]

J'ai un gros problème d'erreur de segmentation dans mon programme.

Merci de livrer la version qui compile...

Project : Forums
Compiler : GNU GCC Compiler (called directly)
Directory : C:\dev\forums2\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: main.c
main.c: In function `ajoutP':
main.c:25: warning: implicit declaration of function `malloc'
main.c:26: warning: implicit declaration of function `strcpy'
main.c: At top level:
main.c:32: warning: function declaration isn't a prototype
main.c: In function `ajoutSociete':
main.c:34: error: `NULL' undeclared (first use in this function)
main.c:34: error: (Each undeclared identifier is reported only once
main.c:34: error: for each function it appears in.)
main.c:35: warning: implicit declaration of function `printf'
main.c:36: warning: implicit declaration of function `scanf'
main.c:41: warning: passing arg 2 of `ajoutP' discards qualifiers from pointer target type
main.c: At top level:
main.c:47: warning: return type defaults to `int'
main.c:47: warning: function declaration isn't a prototype
Process terminated with status 1 (0 minutes, 2 seconds)
3 errors, 8 warnings

Ceci compile et s'exécute, mais n'est ni fiable ni optimisé.

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
//Structure des produits de la société (fichier.h)
typedef struct l1
{
   char nomp[30];
   struct l1 *suivant;
}
Elt1;
 
typedef Elt1 *ListeP;
 
//Structure de données Société
typedef struct
{
// int clesociete;
   char nom[30];
   char adresse[50];
   ListeP Produits;
}
Societe;
 
ListeP ajoutP (ListeP prod, char const *nm)
{
   ListeP new = prod;
   prod = (ListeP) malloc (sizeof (Elt1));
   strcpy (prod->nomp, nm);
   prod->suivant = new;
   return prod;
}
 
Societe ajoutSociete (void)
{
   Societe s;
   s.Produits = NULL;
   printf ("Saisissez le nom de la société : ");
   scanf ("%s", s.nom);
   printf ("Saisissez l'adresse de la socitété : ");
   scanf ("%s", s.adresse);
   printf ("Saisissez le nom du produit : ");
   printf ("bouh1");
 
   s.Produits = ajoutP (s.Produits, "tondeuse");
 
   printf ("bouh2");
   printf ("%s %s", s.nom, s.adresse);
 
/* -ed- BUG : manquait */
   return s;
}
 
int main (void)
{
   Societe tmp;
   tmp = ajoutSociete ();
   printf ("%s %s %s", tmp.nom, tmp.adresse, tmp.Produits->nomp);
 
   return 0;
}

[Médinoc]

Et n'utilise pas scanf("%s"), c'est aussi dangereux qu'utiliser gets().
Sachant que seuls les gourous savent utiliser scanf() correctement (et que je n'en fais pas partie), je te conseille d'utiliser fgets() à la place.

[koala01]

Salut,

A titre personnel, il y a deux choses qui me chagrinent quelque peux:

La premiere, c'est que, comme la liste est créée dynamiquement, il me semblerait utile d'utiliser plutot un pointeur comme parametre et comme type de retour de la fonction ajouteP (avec l'adaptation qui en découle), qui deviendrait

Code :

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

1
2
3
4
5
6
7
8
9
 
ListeP* ajoutP (ListeP* prod, char *nm)
{
    ListeP *new=prod;
    prod=malloc(sizeof(Elt1));
    strcpy(prod->nomp, nm);
    prod->suivant = new;
    return prod;
}

ne serait-ce que parce que faire un malloc sur autre chose qu'un pointeur (ou un pointeur de pointeur)

La deuxieme, c'est au niveau de la logique en elle-meme de cette fonction:

Tout laisse à croire que, effectivement, tu décide de travailler avec une liste simplement chainée...

Il semblerait donc logique que l'ajout se fasse... en fin de liste...

Or la logique suivie rajoute un élément... en début de liste...

Bref, la logique réelle et celle des noms sont en contradiction...

De deux choses l'une:

• Soit, tu veux utiliser un système de type FILO (First In, Last Out),
• Soit tu veux utiliser effectivement une file (avec tout ce que cela implique: possiblité de tri, d'insertion au début, au milieu ou à la fin...)

Dans le premier cas, le nom du type serait plus logiquement pile (ou similaire) et le pointeur sur l'élément actuellement nommé suivant serait plus judicieusement nommé precedent, la fonction ajouteP pouvant alors rester sensiblement pareille (à l'exception du fait qu'il faudrait modifier suivant en precedent )

Dans le second cas, la fonction ajouteP devrait soit etre renommée judicieuxement en "inseredebutP" (par exemple), car c'est ce qu'elle fait, soit etre modifiée pour ajouter effectivement le nouvel élément... en fin de liste...

Ce qui signifie: avoir réellement, avant l'ajout, l'acces au dernier élément de la liste, et utiliser, selon le début du code new->suivant = prod, et non prod->suivant= new...

D'ailleurs, quand on y pense... et sans prendre en compte les éléments de réflexion que je viens de livrer...

Pourquoi ne pas, tout simplement, allouer directement le nouvel élément sur new sous la forme de

Code :

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

1
2
3
4
5
6
7
8
9
 
ListeP* ajoutP (ListeP* prod, char *nm)
{
    ListeP *new;
    new=malloc(sizeof(Elt1));
    strcpy(prod->nomp, nm);
    prod->suivant = new;
    return new;
}

<EDIT>: cette simple modification aurait le dont "quasi miraculeux" de faire correspondre la logique utilisée avec la logique du nommage des différents éléments de structures (ajouter le nouvel élément apres le dernier, et non ajouter la liste existante "a la suite" du nouvel élément)</EDIT>

PS: je sais que ce ne sont là que quelques détails d'implémentation, mais, l'expérience m'a déjà prouvé à maintes reprises qu'il est beaucoup plus facile de travailler avec des variables dont le nom correspond réellement à ce que l'on veut faire