Discussion :

[cricos]

Bonsoir chers amis. J'aimerais votre aide sur ce tp
On souhaite faire une appli pour créer et manipuler un graphe généalogique où les personnes seront reliées entre elles via leurs liens de parenté.
Une variable de type PERSONNE est un pointeur sur une structure pour stocker (le père, la mère, etc.).
Une liste de PERSONNE est une liste chaînée , permettant de stocker des objets de type PERSONNE.
J'ai proposé la définition des structures suivantes.Pensez vous que c'est correcte ? Sinon proposez moi des améliorations.

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
 
 
typedef struct Personne_struct Personne_struct ;
struct Personne_struct
{   int numero;
     char * nom ;
    char *prénom ;
    int annee_nais;
    int annee_deces;
    Personne_struct *pere;
    Personne_struct *mere;
    liste conjoint;
    liste ex_conjoint;
    liste enfant;
 
};
 
typedef struct Personne_list Personne_list ;
struct Personne_list
{
    Personne_struct personne;
    Personne_struct *suivant;
}
 
typedef struct liste liste ;
struct liste
{
 
    Personne_list *premier;
}

[Bktero]

Deux remarques à chaud :

1- on ne dit pas "condjoint"
2- on parle d'arbre généalogique alors pourquoi avoir une liste chaînée alors qu'il faudrait un.....arbre ?

[cricos]

Merci pour la remarque.
En fait le tp a un but pédagogique. C'est de pouvoir savoir manipuler les listes chaînées.Elles serviront à manipuler les enfants et les conjoints ou ex-conjoints d'une personne.
Merci

[Bktero]

OK c'est une précision importante pour justifier l'usage de la liste chaînée.

Dans ce cas une dernière remarque importante : supprime ton type liste et utilise Personne_liste directement. Cacher un pointeur derrière un typedef est souvent source de complexité. De plus cela serait plus symétrique dans la définition de ta structure, au niveau des champs. En effet tes types perso sont déjà utilisés avec des pointeurs.

Personnellement, j'aurais simplement appelé Personne_struct Personne et Personne_liste Groupe

[cricos]

si j'ai bien compris on aura :

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
 
typedef struct Personne_struct Personne_struct ;
struct Personne_struct
{   int numero;
     char * nom ;
    char *prénom ;
    int annee_nais;
    int annee_deces;
    Personne_struct *pere;
    Personne_struct *mere;
   struct Personne_list *conjoint;
  struct Personne_list *ex_conjoint;
  struct Personne_list *enfant;
 
 
*
};
*
typedef struct Personne_list Personne_list ;
struct Personne_list
{
    Personne_struct personne;
    Personne_struct *suivant;
}
typedef Personne_list * llist;
*

sinon merci d'être plus explicite.

[ternel]

Puisque ta structure de liste contient un pointeur, tu n'as pas besoin de mettre un pointeur de liste dans ta structure personne.

Pourquoi faire une structure de liste, pour le frere, alors que tu n'en as pas fait pour le pere ou la mere?

Si tu avais les liens vers les freres (plus proches aine et cadet), tu n'aurais pas besoin d'un pointeur de liste de fils.
Le fils ainé suffirait à avoir toute la fratrie.

Prévois-tu vraiment d'avoir plusieurs conjoints? ca existe, ca n'est pas le débat, mais je doute que ce soit l'attente du sujet de TP.
Si ce n'est pas le cas, un simple pointeur de personne suffirait.

Attention toutefois, tous tes pointeurs ne se valent pas!
Certains correspondent à des allocations, tandis que d'autres sont des simples références.
Pour gérer proprement la mémoire, il faudra libérer chaque allocation une et une seule fois.
Je pense que garder à coté des généalogies une liste de toutes les personnes allouées permettrait de ne pas te tromper.

C'est un vrai problème, qu'il faut toujours garder en tête.

[Bktero]

Ton dernier typedef n'est pas utilisé. Tu ne dois pas mettre d'accent dans tes noms.

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
typedef struct Personne Personne;
 
struct Personne
{
    int numero;
    char *nom;
    char *prenom;
    int annee_nais;
    int annee_deces;
    Personne *pere;
    Personne *mere;
    struct Groupe *conjoint;
    struct Groupe *ex_conjoint;
    struct Groupe *enfant;
};
 
typedef struct Groupe Groupe;
 
struct Groupe
{
    Personne personne;
    Personne *suivante;
};

Je m'interroge quand même sur la définition de ton groupe et de sa capacité en faire une liste chainée. Normalement, un élément d'une liste chainée contient la donnée qui nous intéresse (ici, une personne) et un pointeur vers un autre élément. Ici, tu as bien la donnée, mais tu as un pointeur vers une autre personne et non vers un autre élément de ta liste. Comment comptes-tu parcourir ta liste (d'un point de vue algorithmie) ?

[cricos]

Effectiviement
la correction est faite.Merci

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
 
 
typedef struct Personne Personne;
 
struct Personne
{
    int numero;
    char *nom;
    char *prenom;
    int annee_nais;
    int annee_deces;
    Personne *pere;
    Personne *mere;
    Personne *conjoint;
    struct Groupe *ex_conjoint;
    struct Groupe *enfant;
};
 
typedef struct Groupe Groupe;
 
struct Groupe
{
    Personne personne;
    Groupe *suivant;
};

[ternel]

Prenons une situation assez classique, Madame F a un enfant E1 de son premier mari H1 puis un enfant E2 de son deuxième mari H2. (F+H1->E1 et F+H2->E2)
Théoriquement, on devrait avoir en tout:

• cinq allocations de personnes: F, H1, H2, E1 et E2.
• H1.enfants indique F1
• H2.enfants indique F2
• M.enfants indique F1 et F2

Et pour les familles recomposées: F1+H1 -> E1 et F2+H2 -> E2. Les deux couples divorcent puis F1 et H2 se marient.

Ces deux exemples signifient que les listes d'enfants des deux membres du couple ne doivent pas être la même liste.
Mais si ce n'est pas la même liste, il ne faut pas non plus copier les enfants, et donc bien utiliser des pointeurs.

La question est encore une fois qui possède la mémoire correspondant aux enfants.
Une réponse pourrait être sa mère biologique (mais en ce cas, il faudrait un moyen de savoir en lisant une personne si c'est la mère ou le père de ses enfants).
Une autre réponse serait personne dans le graphe, mais une liste à part.

La bonne réponse dépendra des manipulations que tu veux pouvoir faire dans le graphe.

[Matt_Houston]

Tout comme ternel, je m'interroge sur la pertinence de référencer les conjoints dans un arbre généalogique, à moins que l'on veuille réellement modéliser la sémantique d'union « actuelle », « officielle », etc.. Si l'on cherche à connaître l'autre parent à partir de l'un, il convient de remonter au niveau de la progéniture qui stocke cette information.