problème avec les structures.

Version imprimable

Bonjour tout le monde !

J'ai un sacré soucis depuis quelques temps et rien n'y fait je ne trouve pas la solution.

Imaginons qu'une structure A contienne une variable définie par une autre structure B et que cette structure B contienne elle aussi une variable du type de la structure A.

Voyez vous même :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 typedef struct noeud noeud; typedef struct Sommet Sommet; struct noeud { Sommet val; struct noeud* fils, *frere; }; typedef noeud* Arbre; struct Sommet { int numero; double x; double y; char nom[512]; double PPC; Arc* arrive_par; Arbre* noeudArbreACM; int estTraite; };
(Je vous épargne les structures de Files,d'Arc et de Listes mais elles présentent le même problème).

Bref Si quelqu'un sait comment faire pour éviter les erreurs (enfin toutes les erreurs quoi) comme :
expected specifier qualifier before...
ou bien
field ... has an incomplete type
je prends bien volontiers !

Merci d'avance.

Bonsoir,

les règles sont relativement simples. Tu ne peux pas utiliser une struct avant de la définir puisque qu'on en connaît rien à part le nom. Tu peux cependant utiliser un pointeur sur la struct (on connaît toujours la taille d'un pointeur).

Dans ton cas struct noeud est composé d'un membre de type Sommet -> tu dois définit Sommet avant struct Noeud. Sommet n'est composé que de membre de type de base (int, char, pointeur ...) il n'y a donc rien de particulier à faire.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 typedef struct noeud noeud; typedef struct Sommet Sommet; typedef noeud* Arbre; struct Sommet { int numero; double x; double y; char nom[512]; double PPC; Arc* arrive_par; Arbre* noeudArbreACM; int estTraite; }; struct noeud { Sommet val; struct noeud* fils, *frere; };

13/05/2013, 20h40
Obsidian
Hello,

Citation:

Envoyé par Chadocan

Imaginons qu'une structure A contienne une variable définie par une autre structure B et que cette structure B contienne elle aussi une variable du type de la structure A.

Une structure ne peut pas s'auto-contenir, et plusieurs structure ne peuvent pas plus se contenir mutuellement, car si tu définis une structure A contenant une structure B contenant une structure A contenant une structure B contenant une structure A… alors par définition, toute instance d'un tel objet aurait une taille infinie.

Par contre, tu peux faire en sorte qu'elles se référencent mutuellement, avec des pointeurs. Pour cela, il faut faire une déclaration partielle : tu commences par écrire struct A; et struct B; pour que le compilateur soit averti de leur existence et de leur nature, puis tu déclares le contenu de chacune d'elles :
Code:

1 2 3 4 5 6 7 8 9 10 11 struct A { int data; struct B * ptr; }; struct B { int data; struct A * ptr; };
Citation:

Voyez vous même :

Code:

typedef noeud* Arbre;

C'est une très mauvaise idée de cacher un pointeur dans un typedef, même si c'est une pratique répandue dans les écoles (il est assez fréquent qu'on y fusionne l'introduction au langage C et le cours sur les structures de données).
Citation:
Bref Si quelqu'un sait comment faire pour éviter les erreurs (enfin toutes les erreurs quoi) comme :
expected specifier qualifier before...
Ça, c'est en général dû à une erreur de syntaxe. Si le code est propre, ça veut dire que la déclaration du type que tu utilises à cet endroit a échoué en amont.

Citation:

ou bien field ... has an incomplete type

Ça, par contre, c'est parce que tu as fait légitiment une déclaration incomplète, et que tu ne l'as pas finie.

(Edit: encore trop tard).

Citation:
Envoyé par kwariz
Bonsoir,

les règles sont relativement simples. Tu ne peux pas utiliser une struct avant de la définir puisque qu'on en connaît rien à part le nom. Tu peux cependant utiliser un pointeur sur la struct (on connaît toujours la taille d'un pointeur).

Dans ton cas struct noeud est composé d'un membre de type Sommet -> tu dois définit Sommet avant struct Noeud. Sommet n'est composé que de membre de type de base (int, char, pointeur ...) il n'y a donc rien de particulier à faire.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 typedef struct noeud noeud; typedef struct Sommet Sommet; typedef noeud* Arbre; struct Sommet { int numero; double x; double y; char nom[512]; double PPC; Arc* arrive_par; Arbre* noeudArbreACM; int estTraite; }; struct noeud { Sommet val; struct noeud* fils, *frere; };
Sommet utilise des types de bases mais aussi : Arc* et Arbre* (qui est un pointeur sur noeud) d'où mon problème.

@Obsidian Donc si j'ai bien compris dans ce genre de situation je ne peux pas mettre Sommet val car on ne connait pas la taille de Sommet, mais je peux mettre Sommet* val car on connait la taille d'un pointeur?
En conséquence dans ce genre de problème, il suffit de changer le type de ma variable en pointeur et donc de mettre des * partout dans le reste de mon code?

Merci pour vos réponses.

Citation:

Envoyé par Chadocan

Sommet utilise des types de bases mais aussi : Arc* et Arbre* (qui est un pointeur sur noeud) d'où mon problème.

Ce n'est pas un problème tant qu'il s'agit de pointeurs. Tu fais une forward declaration sur le struct noeud (= tu dis qu'il existe une structure nommée struct noeud). Tu parras dès cet instant utiliser un pointeur sur cette struct mais jamais la struct elle-même jusqu'à ce que tu la définisse entièrement :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 struct noeud; // On averti le compilateur de l'existence de cette structure // À partir d'ici tu peux utiliser des pointeurs sur struct noeud mais pas struct noeud typedef struct noeud noeud_t; // c'est OK car tu définis un alias // mais comme c'est un alias tu ne pourras pas l'utiliser avant // d'avoir définit struct noeud, mais tu pourras utiliser des pointeurs sur noeud_t struct arbre { struct noeud *racine; // OK car on utilise qu'un pointeur .... }; struct noeud { // Ici on donne le détail de struct noeud }; // À partir d'ici tu peux utiliser struct noeud struct info_noeud { struct noeud node; .... };

Ok,
Le soucis c'est que je ne parviens pas à résoudre mon problème de cette manière (sans pointeur donc). Car en réalité j'ai plusieurs fichiers :

fichier arbre.h :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#ifndef _ARBRE
#define _ARBRE
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
#include "fileACM.h"
typedef struct noeud noeud;
typedef struct Sommet Sommet;
typedef noeud* Arbre;
 
typedef struct noeud
{
    Sommet* val;
    struct noeud* fils, *frere;
};
 
 
#endif

fichier fileACM.h

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
 
#ifndef FILEACM_H_INCLUDED
#define FILEACM_H_INCLUDED
 
#include <stdio.h>
#include <stdlib.h>
#include <float.h>
#include "arbre.h"
#include "files.h"
 
 
struct Sommet
{
    int numero;
    double x;
    double y;
    char nom[512];
    File fileARC;
    double PPC;
    Arc* arrive_par;
	Arbre* noeudArbreACM;
    int estTraite;
};
#endif // FILEACM_H_INCLUDED

13/05/2013, 22h31
kwariz
Dans FileACM tu dois mettre des forward declarations de Arc et Arbre pour pouvoir utiliser des pointeur sur eux :
Code:

1 2 typedef struct arc Arc; typedef struct noeud *Arbre;
Mais utiliser un pointeur sur sommet est tout aussi valide.

Attention, je vois que tu utilises un Arbre* aussi (donc un struct noeud**) ... est-ce correct dans ta conception ? Prends en compte la bonne remarque d'Obsidian concernant le nommage de tes types.
13/05/2013, 22h35
Chadocan

J'ai rajouté ces deux lignes et j'ai enlevé sommet pour mettre un int dans mon arbre, j'ai corrigé ce fameux arbre* et c'est encore pire : 11 erreurs portants toutes sur mes structures, je suis perdu :(.
Pourquoi ne faut t'il pas écrire
typedef noeud* arbre ?
13/05/2013, 22h36
kwariz

Ajoute la bonne ligne pour arc quand même ...

bon reprenons depuis le début,voilà tous mes fichiers.h il y'a quelques truc atypique j'imagine, pour le reste j'ai fais comme on me l'a enseigné (visiblement mal enseigné), qu'est ce que j'ai loupé?

Listes.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#ifndef LISTES_H_INCLUDED
#define LISTES_H_INCLUDED
 
#include "fileACM.h"
 
typedef struct Maillon Maillon;
struct Maillon
{
    Sommet val;
    Maillon* suivant;
};
typedef Maillon* Liste;
 
#endif // LISTES_H_INCLUDED

files.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#ifndef FILES_H_INCLUDED
#define FILES_H_INCLUDED
 
#include <stdio.h>
#include <stdlib.h>
 
typedef struct Arc
{
    int sommetDepart;
    int sommetArrivee;
    double cout;
};
 
typedef Arc Element;
 
typedef struct Chainon
{
    Element val;
    struct Chainon* suivant;
}Chainon;
typedef Chainon* File;
 
#endif // FILES_H_INCLUDED

fileACM.h

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
#ifndef FILEACM_H_INCLUDED
#define FILEACM_H_INCLUDED
 
#include <stdio.h>
#include <stdlib.h>
#include <float.h>
#include "arbre.h"
#include "files.h"
 
typedef struct Arc Arc;
typedef struct noeud *Arbre;
 
//Structure de Sommet.
typedef struct Sommet Sommet;
struct Sommet
{
    int numero;
    double x;
    double y;
    char nom[512];
    File fileARC;
    double PPC;
    Arc* arrive_par; 
    Arbre noeudArbreACM;  
    int estTraite; 
};
 
#include "listes.h" //noté l'emplacement de liste.h, sinon ça fait tout planter
 
void swap(int* a,int* b);
void afficheGraphe(Sommet* tabSommet,int tailleTableau);
File ACM(char* nomDuFichier,Sommet* tabSommet);
Sommet* lectureGraphe(char* nomDuFichier,int * nombreSommets,Sommet* lectureGraphe);
Liste rechercheCoutMinimum(Liste C);
 
#endif // FILEACM_H_INCLUDED

arbre.h

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#ifndef _ARBRE
#define _ARBRE
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
 
#include "fileACM.h"
 
typedef struct noeud
{
    int val;
    struct noeud* fils, *frere;
} * ARBRE;
 
 
#endif

On commence par :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 #ifndef FILES_H_INCLUDED #define FILES_H_INCLUDED #include <stdio.h> #include <stdlib.h> typedef struct Arc { int sommetDepart; int sommetArrivee; double cout; }; typedef Arc Element; typedef struct Chainon { Element val; struct Chainon* suivant; }Chainon; typedef Chainon* File; #endif // FILES_H_INCLUDED
typedef Arc Element; definit le type Element comme étant un synonyme pour le type Arc ... le type Arc n'existe pas (enfin je suppose) car tu voulais sans doute dire typedef struct Arc Element;.
Je me trompe ?

13/05/2013, 22h56
Chadocan
En fait j'avais mis ca :
Code:

1 2 3 4 5 6 7 typedef struct Arc { int sommetDepart; int sommetArrivee; double cout; }Arc; typedef Arc Element
toutes mes fonctions sur les files travaillent avec un type Element comme ca je peux les utiliser pour différents projets en changeant juste le typedef.

Comme vous m'avez suggérer de mettre

Code:

typedef struct Arc Arc;

dans fileACM et que mon compilateur râlait pour avoir fais 2 définitions de Arc j'ai enlevé le }Arc; de ma structure.

J'ai fait quelques modifications :
Code:

1 2 3 4 5 typedef struct noeud* Arbre; struct Sommet { ... }
Code:

1 2 3 4 5 6 typedef struct Sommet Sommet; typedef struct noeud { Sommet* val; struct noeud* fils, *frere; } * ARBRE;

On va mettre ça un peu à plat :)
On commence par arbre.h
Code:

1 2 3 4 5 6 7 8 9 10 #ifndef _ARBRE #define _ARBRE typedef struct noeud { int val; struct noeud* fils, *frere; } * Arbre; #endif
Tu n'as pas besoin de plus, j'ai mis Arbre au lieu de ARBRE.

----

Ensuite files.h
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 #ifndef FILES_H_INCLUDED #define FILES_H_INCLUDED typedef struct Arc { int sommetDepart; int sommetArrivee; double cout; } Arc, Element; typedef struct Chainon { Element val; struct Chainon* suivant; }Chainon; typedef Chainon* File; #endif // FILES_H_INCLUDED
À nouveau tout ce que tu utilises est défini.
----
Je te propose de rajouter un fichier sommet.h :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 #ifndef SOMMET_H_INCLUDED #define SOMMET_H_INCLUDED #include "arbre.h" // pour avoir struct noeud et Arbre #include "files.h" // pour avoir Arc //Structure de Sommet. typedef struct Sommet Sommet; struct Sommet { int numero; double x; double y; char nom[512]; File fileARC; double PPC; Arc* arrive_par; Arbre noeudArbreACM; int estTraite; }; #endif
sommet.h défini ce qu'est un sommet tout simplement.

----
listes.h
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #ifndef LISTES_H_INCLUDED #define LISTES_H_INCLUDED #include "sommet.h" // pour avoir la définition de Sommet typedef struct Maillon Maillon; struct Maillon { Sommet val; Maillon* suivant; }; typedef Maillon* Liste; #endif // LISTES_H_INCLUDED
----

Et on finit avec fileACM.h :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 #ifndef FILEACM_H_INCLUDED #define FILEACM_H_INCLUDED #include "listes.h" // pour Liste #include "files.h" // pour File #include "sommet.h" // pour sommet void swap(int* a,int* b); void afficheGraphe(Sommet* tabSommet,int tailleTableau); File ACM(char* nomDuFichier,Sommet* tabSommet); Sommet* lectureGraphe(char* nomDuFichier,int * nombreSommets,Sommet* lectureGraphe); Liste rechercheCoutMinimum(Liste C); #endif // FILEACM_H_INCLUDED
Là tu devrais avoir un hiérarchie plus ou moins correcte ...
Mais attention au nommage de tes types qui sont limite ... comme par exemple File que l'on pourrait confondre avec FILE de stdio, rien a priori ne distingue un identifiant de type et le nom d'une variable, de bien regrouper et séparer dans tes modules, n'inclure les stdio et cie que là où on en a besoin, séparer arc et chainon ...

13/05/2013, 23h46
Chadocan

Ah, effectivement ça à l'air bien mieux, faut que j'essaye tout ça maintenant, j'ai un peu peur pour le fileACM.h, il se fait tard je ferais ça une autre fois.

Citation:

Mais attention au nommage de tes types qui sont limite ... comme par exemple File que l'on pourrait confondre avec FILE de stdio, rien a priori ne distingue un identifiant de type et le nom d'une variable, de bien regrouper et séparer dans tes modules, n'inclure les stdio et cie que là où on en a besoin, séparer arc et chainon ...

C'est pas faux, j'ai pris pour la plupart les noms de types et de variables que notre prof utilise en cours. Par contre normalement je distingue Type et variables d'une majuscule en première lettre, même si la ce n'est pas fait (en plus c'est un travail de groupe ca n'aide pas). Pour le reste c'est vrai que c'est l'horreur j'ai jamais vraiment bien compris la programmation modulaire, mais j'ai bien avancé ce soir :) .
Merci pour cette aide.
14/05/2013, 10h48
ternel
programmation modulaire, c'est juste pour dire qu'on travaille avec des blocs isolables.

Ici, tu as d'un coté le concept de file, de l'autre celui d'arbre.
Ces deux concepts devrait être utilisable par un programme arbitraire en incluant un en-tête distinct pour chacun (typiquement file.h et arbre.h)

Tu peux imaginer un fichier les regroupant, pour simplifier l'usage
Code:

1 2 3 4 5 6 7 //conteneur.h //pas besoin de garde, il n'y a que des includes gardés. #include "file.h" #include "arbre.h" //#include "pile.h" //#include "ensemble.h"
Les modules devant être conciliant, on aura tendance à réduire les en-têtes "publics" pour ne laisser que ce qu'on veut vraiment exporter.
On prendra alors grand soin de choisir des noms peu propices à être utilisé par un autre développeur, dans ses propres en-têtes.