---
# System prepended metadata

title: Untitled

---

Heri:

```cpp
void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC){
  int ind;
  bool ajoutOK = true;
  if (EC.nbP == MAXPERSONNES) {
    ajoutOK = false;
    cout << "La base est pleine, on ne peut pas ajouter une personne." << endl;
  } else {
    for (int i = 0; i < EC.nbP; i++) // interdire l'homonymie
        if (EC.tableP[i].nom == sonNom) {
            ajoutOK = false;
            cout << "La personne " << sonNom << " existe deja dans la base." << endl;
            break;
        }
    if (ajoutOK == true) {
        ind = EC.nbP;
        EC.tableP[ind].nom = sonNom;
        EC.tableP[ind].genre = s;
        EC.tableP[ind].indConjoint = -1; // pas de conjoint
        EC.tableP[ind].indParent1 = parent1;
        EC.tableP[ind].indParent2 = parent2;
        EC.nbP++; // mise a jour du nombre de personnes
    }
  }
}
```

Julien : 
```cpp
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;

#define ASSERT(test) if (!(test)) std::cout << "Test failed in file " << __FILE__ \
				       << " line " << __LINE__ << ": " #test << std::endl

const int MAXPERSONNES = 50;

enum Genre { M, F };

struct Personne{
  string nom;
  Genre genre;
  int indConjoint, indParent1, indParent2;
};

struct EtatCivil {
   Personne tableP[MAXPERSONNES];
   int nbP;
};

void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC){
	bool ajout = true;
	if (EC.nbP == MAXPERSONNES){
		cout << "La base de données est pleine, on ne peut ajouter personne" << endl;
	} else if (parent1 >= -1 and parent1 < 50 and parent2 >= -1 and parent2 < 50){
		cout << "Vérifiez les données parentales" << endl;
	} else if (sonNom.size()>20){
		cout << "Le nom entré est trop long, merci de corriger" << endl;
	}	else {
		for (int i = 0; i <EC.nbP; i++){
			if (sonNom == EC.tableP[i].nom){
				cout << "Une personne a déjà ce nom, ajout impossible" << endl;
				ajout = false;
				break;
			}
		}
		if (ajout){
			EC.tableP[EC.nbP].nom = sonNom;
			EC.tableP[EC.nbP].genre = s;
			EC.tableP[EC.nbP].indParent1 = parent1;
		  EC.tableP[EC.nbP].indParent2 = parent2;
			EC.tableP[EC.nbP].indConjoint = -1;
		  EC.nbP ++;
		}
	}
}

void AffichePersonne(int ind, EtatCivil EC){
  if (EC.tableP[ind].genre == M){
			cout << EC.tableP[ind].nom << " est un homme";
	} else {
			cout << EC.tableP[ind].nom << " est une femme";
  }
	if (EC.tableP[ind].indConjoint >= 0){
		cout << " qui est marié à " << EC.tableP[EC.tableP[ind].indConjoint].nom;
	}
	if (EC.tableP[ind].indParent1 >= 0){
		cout << " qui a pour parent " << EC.tableP[EC.tableP[ind].indParent1].nom;
	}
	if (EC.tableP[ind].indParent2 >= 0){
		if (EC.tableP[ind].indParent1 >= 0)
			cout << " et ";
		else
			cout << " qui a pour parent ";
		cout << EC.tableP[EC.tableP[ind].indParent2].nom;
	}
	cout << endl;
}


void AfficheEtatCivil(EtatCivil EC){
  for (int i = 0; i < EC.nbP; i++){
    AffichePersonne(i,EC);
  }
}

void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}

int recherchePersonne (EtatCivil EC, string nom){
	int r = -1;
	for (int i = 0; i < MAXPERSONNES; i++){
		if (EC.tableP[i].nom == nom)
			r = i;
	}
	return r;
}

bool mariage(string nom1, string nom2, EtatCivil &EC){
	int p1 = recherchePersonne(EC, nom1);
	int p2 = recherchePersonne(EC, nom2);
	bool res = false;
	if (p1 >= 0 && p2 >= 0){
		if (EC.tableP[p1].indConjoint < 0 && EC.tableP[p2].indConjoint < 0){
			EC.tableP[p1].indConjoint = p2;
			EC.tableP[p2].indConjoint = p1;
			res = true;
		}
	}
	return res;
}

void arbre (int nb, int indice, EtatCivil EC){
	for (int i = 0; i < indice; i++){
		cout << "  |";
	}
	if (nb >= 0){
		cout << EC.tableP[nb].nom << endl;
		indice++;
		arbre (EC.tableP[nb].indParent1, indice, EC);
		arbre (EC.tableP[nb].indParent2, indice, EC);
	} else {
		cout << "Inconnu" << endl;
	}
}


int main() {
  EtatCivil EC;
  EC.nbP = 0; // il est necessaire d'initialiser le nombre de personnes
  RemplitEtatCivil(EC);
  AjoutPersonne("Jean",M,-1,-1, EC);
  AjoutPersonne("Jeanne",F,-1,-1,EC);
  AfficheEtatCivil(EC);
	cout << endl;
	AffichePersonne(recherchePersonne(EC,"Luc"),EC);

	mariage("Jean","Jeanne",EC);
	AffichePersonne(recherchePersonne(EC,"Jean"),EC);
	AffichePersonne(recherchePersonne(EC,"Jeanne"),EC);
	cout << endl;
	arbre (8, 0, EC);
}

```

Corntin : 
``` cpp
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;

const int MAXPERSONNES = 50;

enum Genre { M, F };

struct Personne{
  string nom;
  Genre genre;
  int indConjoint, indParent1, indParent2;
};

struct EtatCivil {
   Personne tableP[MAXPERSONNES];
   int nbP;
};

void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC){
    bool a = true;
    for(int i = 0; i < EC.nbP; i++){
        if(sonNom == EC.tableP[i].nom){
            cout<<"Nom deja utilise"<<endl;
            a = false;
        }
    }
    if(EC.nbP < MAXPERSONNES and a){
        EC.tableP[EC.nbP] = {sonNom, s, -1, parent1, parent2};
        EC.nbP++;
    }else{
        cout<<"Impossible de rajouter cette personne"<<endl;
    }
}

void AffichePersonne(int ind, EtatCivil EC){
    cout<<"Nom : "<<EC.tableP[ind].nom<<endl;
    cout<<"Genre : ";
    if(EC.tableP[ind].genre == M){
        cout<<"Homme"<<endl;
    }else if(EC.tableP[ind].genre == F){
        cout<<"Femme"<<endl;
    }else{
        cout<<"Non Binaire"<<endl;
    }
    cout<<"Indice du conjoint : "<<EC.tableP[ind].indConjoint<<endl;
    cout<<"Indice du parent 1 : "<<EC.tableP[ind].indParent1<<endl;
    cout<<"Indice du parent 2 : "<<EC.tableP[ind].indParent2<<endl;
}

void AfficheEtatCivil(EtatCivil EC){
    for(int i = 0; i < EC.nbP; i++){
        AffichePersonne(i, EC);cout<<endl;
    }
}

void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}

int recherchePersonne(string nomP, EtatCivil EC){
    for(int i = 0; i < EC.nbP; i++){
        if(EC.tableP[i].nom == nomP){
            return i;
        }
    }
    return -1;
}

bool mariage(string nom1, string nom2, EtatCivil &EC){
    int P1 = recherchePersonne(nom1, EC);
    int P2 = recherchePersonne(nom2, EC);
    if(P1 != -1 and P2 != -1){
        if(EC.tableP[P1].indConjoint == -1 and EC.tableP[P2].indConjoint == -1){
            EC.tableP[P1].indConjoint = P2;
            EC.tableP[P2].indConjoint = P1;
            return true;
        }
    }
    return false;
}

void arbreGenealogique(int indiceP, EtatCivil EC, int compteur){
    for(int i = 0; i < compteur; i++){
        cout<<"    ";
    }
    cout<<"Individu "<<indiceP<<endl;
    if(EC.tableP[indiceP].indParent1 == -1){
        for(int i = 0; i < compteur+1; i++){
            cout<<"    ";
        }
        cout<<"Individu Inconnu"<<endl;
    }else{
        arbreGenealogique(EC.tableP[indiceP].indParent1, EC, compteur + 1);
    }
    if(EC.tableP[indiceP].indParent2 == -1){
        for(int i = 0; i < compteur+1; i++){
            cout<<"    ";
        }
        cout<<"Individu Inconnu"<<endl;
    }else{
        arbreGenealogique(EC.tableP[indiceP].indParent2, EC, compteur + 1);
    }
}  


int main() {
  EtatCivil EC;
  EC.nbP = 0; // il est necessaire d'initialiser le nombre de personnes
  RemplitEtatCivil(EC);
  arbreGenealogique(9, EC, 0);
}
```


Fabrice :
```cpp
#include <cstdlib>
#include <iostream>
#include <string>

const int MAXPERSONNES = 50;

enum Genre { M, F };

char charGenre(Genre const& s) {
  if (s == F) return 'F';
  else return 'M';
}

struct Personne{
  std::string nom;
  Genre genre;
  int indConjoint, indParent1, indParent2;
};

struct EtatCivil {
   Personne tableP[MAXPERSONNES];
   int nbP = 0;
};

void AjoutPersonne(std::string sonNom, Genre s, int parent1, int parent2, EtatCivil& EC) {
  if (EC.nbP + 1 >= MAXPERSONNES) throw("Il y a trop de gens !");

  EC.tableP[EC.nbP] = {sonNom, s, -1, parent1, parent2};
  EC.nbP++;
}

void AffichePersonne(int ind, EtatCivil const& EC) {
  if (ind >= EC.nbP) throw("Je ne connais pas cette personne !");

  std::cout << EC.tableP[ind].nom << " (" << charGenre(EC.tableP[ind].genre) << ")" << std::endl;
}

void AfficheEtatCivil(EtatCivil const& EC) {
  for (int i = 0; i < EC.nbP; i++) AffichePersonne(i, EC);
}

void RemplitEtatCivil(EtatCivil& EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}

int indexPersonne(EtatCivil const& EC, std::string nom) {
  for (int i = 0; i < EC.nbP; i++)
    if (EC.tableP[i].nom == nom) return i;

  return -1;
}

void mariage(EtatCivil& EC, std::string nom1, std::string nom2) {
  int id1 = indexPersonne(EC, nom1);
  int id2 = indexPersonne(EC, nom2);

  if (id1 == -1 || id2 == -1) std::cout << "Impossible de faire un mariage avec quelqu'un qui n'existe pas !" << std::endl;
  else {
    Personne pers1 = EC.tableP[id1];
    Personne pers2 = EC.tableP[id2];

    if (pers1.indConjoint != -1 || pers2.indConjoint != -1) std::cout << "Le mariage multiple n'est pas autorisé !" << std::endl;
    else {
      pers1.indConjoint = id2;
      pers2.indConjoint = id1;
    }
  }
}

void arbreGenealogique(EtatCivil const& EC, int id, int tabs = 0) {
  if (id == -1) return;
  if (id >= EC.nbP) {
    std::cout << "Je ne connais pas cette personne !" << std::endl;
    return;
  }

  std::string espaces = ""; for (int i = 0; i < tabs; i++) espaces += " ";

  Personne pers = EC.tableP[id];

  std::cout << espaces << pers.nom << std::endl;
  arbreGenealogique(EC, pers.indParent1, tabs+1);
  arbreGenealogique(EC, pers.indParent2, tabs+1);
}

int main() {
  EtatCivil EC;
  RemplitEtatCivil(EC);
  AfficheEtatCivil(EC);

  arbreGenealogique(EC, 9);
  //EC.nbP = 0; // il est necessaire d'initialiser le nombre de personnes
}
```


Colin :
```cpp
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;

const int MAXPERSONNES = 50;

enum Genre { M, F };

struct Personne{
  string nom;
  Genre genre;
  int indConjoint, indParent1, indParent2;
};

struct EtatCivil {
   Personne tableP[MAXPERSONNES];
   int nbP;
};

void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC){
    Personne p;
    p.nom = sonNom;
    p.genre = s;
    p.indParent1 = parent1;
    p.indParent2 = parent2;
    bool ok = true;
    if (EC.nbP == MAXPERSONNES){
        cout << "Il y a déjà trop d'utilisateurs";
        ok = false;
    } else {
        for (int i = 0; i < EC.nbP; i++){
            if(EC.tableP[i].nom == sonNom){
                ok = false;
                cout << "Utilisateur déjà enregistré";
            }
        }
        if (ok) {
        EC.tableP[EC.nbP + 1] = p;
        EC.nbP++;
        }
    }
}

void AffichePersonne(int ind, EtatCivil EC){
  if (ind > MAXPERSONNES){ cout << "L'indice donné ne convient pas" << endl; }
  else if (EC.tableP[ind].nom == ""){ cout << "La personne n'existe pas" << endl; }
  else {
      cout << "Prénom :" << EC.tableP[ind].nom << endl;
      if (EC.tableP[ind].genre == M){
          cout << "Genre : Homme" << endl;
      } else { cout << "Genre : Femme" << endl; }
      if (EC.tableP[ind].indParent1 != -1){ 
          cout << "Parent 1 :" << EC.tableP[EC.tableP[ind].indParent1].nom << endl;
      } else { cout << "Nous n'avons pas l'information du premier parent" << endl; }
      if (EC.tableP[ind].indParent2 != -1){ 
          cout << "Parent 2 :" << EC.tableP[EC.tableP[ind].indParent2].nom << endl;
      } else { cout << "Nous n'avons pas l'information du second parent" << endl; }
  }
}

void AfficheEtatCivil(EtatCivil EC){
    for (int i = 0; i < EC.nbP; i++){
        AffichePersonne(i, EC);
    }
}

int chercheIdentifiant(string name, EtatCivil EC){
    for (int i = 0; i < EC.nbP; i++){
        if (EC.tableP[i].nom == name){
            return i;
        }
    }
    return -1;
}

bool mariage(EtatCivil &EC, string nom1, string nom2){
    for (int i = 0; i < EC.nbP; i++){
        if (EC.tableP[i].nom == nom1){
            for (int j = 0; j < EC.nbP; j++){
                if (EC.tableP[j].nom == nom2){
                    if (EC.tableP[j].indConjoint == i){ return false; }
                    EC.tableP[j].indConjoint = i;
                    EC.tableP[i].indConjoint = j;
                    return true;
                }
            }
        }
    }
    return false;
}

void arbreGenealogique(EtatCivil EC, int id, int tab = 0){
    string spaces = ""; 
    for (int i = 0; i < tab; i++){  spaces += " "; }
    if (id != -1){ cout << spaces << EC.tableP[id].nom << endl; }
    else { cout << spaces << "Individu inconnu" << endl;}
    arbreGenealogique(EC, EC.tableP[id].indParent1, tab+2);
    arbreGenealogique(EC, EC.tableP[id].indParent2, tab+2);
}

void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}


int main() {
  EtatCivil EC;
  EC.nbP = 0; // il est necessaire d'initialiser le nombre de personnes
  RemplitEtatCivil(EC);
  AfficheEtatCivil(EC);
  return 0;
}
```

pelouse :
```cpp
#include <cstdlib>
#include <iostream>
#include <string>
#include <iomanip>
using namespace std;

const int MAXPERSONNES = 50;

enum Genre { M, F };

struct Personne{
  string nom;
  Genre genre;
  int indConjoint, indParent1, indParent2;
};

struct EtatCivil {
   Personne tableP[MAXPERSONNES];
   int nbP;
};

void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC){
	Personne p;
	p.nom = sonNom;
	p.genre = s;
	p.indConjoint = -1;
	p.indParent1 = parent1;
	p.indParent2 = parent2;
	if(EC.nbP == 50){
		cout<<"erreur 430, plus de place"<<endl;
		return;
	}
	EC.tableP[EC.nbP] = p;
	EC.nbP++;
}

void AffichePersonne(int ind, EtatCivil EC){
	if(ind > EC.nbP){
		cout<<"error 404, not found"<<endl;
		return;
	}
	Personne p = EC.tableP[ind];
	cout<<p.nom<<" est de sexe "<<p.genre<<endl;
	if(p.indConjoint > -1) cout<<"son conjoint est "<<EC.tableP[p.indConjoint].nom<<endl;
	if(p.indParent1 > -1) cout<< "un de ses parents est "<<EC.tableP[p.indParent1].nom<<endl;
	if(p.indParent2 > -1) cout<< "l'autre est "<<EC.tableP[p.indParent2].nom<<endl;
	cout<<endl;
}

void AfficheEtatCivil(EtatCivil EC){
	for(int i = 0; i < EC.nbP; i++){
		AffichePersonne(i,EC);
	}
}

int rechercheNom(string nom, EtatCivil EC){
	for(int i = 0; i < EC.nbP; i++){
		if(EC.tableP[i].nom == nom) return i;
	}
	return -1;
}
 
bool mariage(string nom1, string nom2, EtatCivil &EC){
	if(EC.tableP[rechercheNom(nom1,EC)].indConjoint == -1 && EC.tableP[rechercheNom(nom2,EC)].indConjoint == -1){
		EC.tableP[rechercheNom(nom1,EC)].indConjoint = rechercheNom(nom2,EC);
		EC.tableP[rechercheNom(nom2,EC)].indConjoint = rechercheNom(nom1,EC);
		return true;
	}
	return false;
}

void arbreGenial(int ind, EtatCivil EC, int i){
	cout<<EC.tableP[ind].nom<<endl;
	for(int j = 0; j <= i; j++){
		cout<<"  ";
	}
	if (EC.tableP[ind].indParent1 == -1) cout<<"Inconnu"<<endl;
	else arbreGenial(EC.tableP[ind].indParent1, EC, i+1);
	for(int j = 0; j <= i; j++){
		cout<<"  ";
	}
	if (EC.tableP[ind].indParent2 == -1) cout<<"Inconnu"<<endl;
	else arbreGenial(EC.tableP[ind].indParent2, EC, i+1);
}

void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 8, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, 9, 14, EC);
  AjoutPersonne("Viviane", F, 0, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}


int main() {
  EtatCivil EC;
  EC.nbP = 0; // il est necessaire d'initialiser le nombre de personnes
  RemplitEtatCivil(EC);
  arbreGenial(rechercheNom("John",EC),EC,0);
}
```





Axel : 
```cpp
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;

const int MAXPERSONNES = 50;

enum Genre { M, F };

struct Personne{
  string nom;
  Genre genre;
  int indConjoint, indParent1, indParent2;
};

struct EtatCivil {
   Personne tableP[MAXPERSONNES];
   int nbP;
};

void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC)
{
    Personne newP;
    newP.nom = sonNom;
    newP.genre = s;
    newP.indConjoint = -1;
    newP.indParent1 = parent1;
    newP.indParent2 = parent2;
    if (EC.nbP >= MAXPERSONNES)
        cout << "erreur, plus de place";
    else {
        EC.tableP[EC.nbP] = newP;
        EC.nbP++;
        cout << newP.nom << " a bien ete rajoute dans l'etat civil bg" << endl;
    }
}

int recherchePersonne(string nom, EtatCivil EC)
{
    for(int i=0; i<EC.nbP; i++){
        if (EC.tableP[i].nom == nom)
            return i;
    }
    return -1;
}

void AffichePersonne(int ind, EtatCivil EC)
{
    if (ind > EC.nbP)
        cout << "Y'a pas la personne dedans :c" << endl;
    else {
        Personne guy;
        cout << "Nom : " << EC.tableP[ind-1].nom << endl;
        cout << "Genre : ";
        if (EC.tableP[ind].genre == M)
            cout << "M";
        else
            cout << "F";
        cout << endl;
        cout << "indice du conjoint : " << EC.tableP[ind-1].indConjoint << endl;
        cout << "indice du parent 1 : " << EC.tableP[ind-1].indParent1 << endl;
        cout << "indice du parent 2 : " << EC.tableP[ind-1].indParent2 << endl;
    }
}

void AfficheEtatCivil(EtatCivil EC)
{
    for(int i=1; i<=EC.nbP; i++)
    {
        AffichePersonne(i, EC);
        cout <<  endl;
    }
}

bool setMariage(int p1, int p2, EtatCivil &EC)
{
    if((EC.tableP[p1].indConjoint != -1 || EC.tableP[p2].indConjoint != -1) || (p1 >= EC.nbP || p2 >= EC.nbP) || p1 == p2){
        cout << "Erreur, mariage pas possible";
        return false;
    } else {
        EC.tableP[p1].indConjoint = p2;
        EC.tableP[p2].indConjoint = p1;
        cout << "mariage effectue!" << endl;
        return true;
    }
}

void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}

void genealogie(int ind, int i, EtatCivil EC)
{
    for (int j=0; j<i; j++){
        cout << "   ";
    }
    if (ind == -1){
        cout << "Individu inconnu" << endl;
    } else {
        cout << EC.tableP[ind].nom << endl;
        int papa = EC.tableP[ind].indParent1;
        int maman = EC.tableP[ind].indParent2;
        genealogie(papa, i+1, EC);
        genealogie(maman, i+1, EC);
    }

}

int main() {
  EtatCivil EC;
  EC.nbP = 0; /// il est necessaire d'initialiser le nombre de personnes
  RemplitEtatCivil(EC);
  cout << endl << endl;
  AfficheEtatCivil(EC);
  cout << recherchePersonne("Boris", EC) << endl;
  setMariage(2, 5, EC);

  genealogie(10, 0, EC);
}


````

Bernard :
 ```cpp
 #include <cstdlib>
#include <iostream>
#include <string>
using namespace std;

const int MAXPERSONNES = 50;

enum Genre { M, F };

struct Personne{
  string nom;
  Genre genre;
  int indConjoint, indParent1, indParent2;
};

struct EtatCivil {
   Personne tableP[MAXPERSONNES];
   int nbP;
};

void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC){
	int t = 0;
	for (int i = 0; i < MAXPERSONNES; i++){
		if (EC.tableP[i].nom != ""){
			t = t + 1;
		}
	}
	if (t >= MAXPERSONNES){
		cout << "Il est impossible d'ajouter une personne dans l'état civil" << endl;
	}else{
		EC.tableP[t].nom = sonNom;
		EC.tableP[t].genre = s;
		EC.tableP[t].indConjoint = -1;
		EC.tableP[t].indParent1 = parent1;
		EC.tableP[t].indParent2 = parent2;
		EC.nbP = EC.nbP + 1;
	}
}

void AffichePersonne(int ind, EtatCivil EC){
	if (EC.tableP[ind].nom != ""){
		cout << "Nom : " << EC.tableP[ind].nom << endl;
		if (EC.tableP[ind].genre == 0){
			cout << "Genre : " << "M" << endl;
		}
		if (EC.tableP[ind].genre == 1){
			cout << "Genre : " << "F" << endl;
		}
		cout << "Conjoint : " << EC.tableP[ind].indConjoint << endl;
		cout << "Parent 1 : " << EC.tableP[ind].indParent1 << endl;
		cout << "Parent 2 : " << EC.tableP[ind].indParent2 << endl;
	}else{
		cout << "Cette personne n'existe pas" << endl;
	}
}

void AfficheEtatCivil(EtatCivil EC){
	for (int i = 0; i < MAXPERSONNES; i++){
		if (EC.tableP[i].nom != ""){
			AffichePersonne(i, EC);
		}
	}
}

int trouvePersonne(string sonNom, EtatCivil EC){
	for (int i = 0; i < MAXPERSONNES; i++){
		if (EC.tableP[i].nom == sonNom){
			return i;
		}
	}
	return -1;
}

bool mariage(string Nom1, string Nom2, EtatCivil EC){
	if (trouvePersonne(Nom1, EC) != -1 and trouvePersonne(Nom2, EC) != -1){
		for (int i = 0; i < MAXPERSONNES; i++){
			if (EC.tableP[i].nom == Nom1){
				for (int j = 0; j < MAXPERSONNES; j++){
					if (EC.tableP[j].nom == Nom2){
						if (EC.tableP[i].indConjoint == -1 and EC.tableP[j].indConjoint == -1){
							return true;
						}
					}
				}
			}
		}
	}
	return false;
}

void arbre(int ind, EtatCivil EC){
	cout << EC.tableP[ind].nom << endl;
	cout << "	";
	if (EC.tableP[ind].indParent1 == -1){
		cout << "Individu Incounnu" << endl;
	}else{
		arbre(EC.tableP[ind].indParent1, EC);
	}
	cout << "	";
	if (EC.tableP[ind].indParent2 == -1){
		cout << "Individu Incounnu" << endl;
	}else{
		arbre(EC.tableP[ind].indParent2, EC);
	}
}

void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}


int main() {
  EtatCivil EC;
  EC.nbP = 0; // il est necessaire d'initialiser le nombre de personnes
  RemplitEtatCivil(EC);
  AfficheEtatCivil(EC);
  arbre(9, EC);
}
````

Alexis:

```cpp
void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC){
  int ind;
  bool ajoutOK = true;
  if (EC.nbP == MAXPERSONNES) {
    ajoutOK = false;
    cout << "La base est pleine, on ne peut pas ajouter une personne." << endl;
  } else {
    for (int i = 0; i < EC.nbP; i++) // interdire l'homonymie
        if (EC.tableP[i].nom == sonNom) {
            ajoutOK = false;
            cout << "La personne " << sonNom << " existe deja dans la base." << endl;
            break;
        }
    if (ajoutOK == true) {
        ind = EC.nbP;
        EC.tableP[ind].nom = sonNom;
        EC.tableP[ind].genre = s;
        EC.tableP[ind].indConjoint = -1; // pas de conjoint
        EC.tableP[ind].indParent1 = parent1;
        EC.tableP[ind].indParent2 = parent2;
        EC.nbP++; // mise a jour du nombre de personnes
    }
  }
}

void AffichePersonne(int ind, EtatCivil EC){

  if(ind < EC.nbP){

    cout << "Nom : " << EC.tableP[ind].nom << endl;
    if (EC.tableP[ind].genre == M){
      cout << "Genre : Masculin" << endl;
    }
    else{
      cout << "Genre : Féminin" << endl;
    }
    if (EC.tableP[ind].indConjoint > -1){
      cout << "Conjoint : " << EC.tableP[EC.tableP[ind].indConjoint].nom << endl;
    }
    else{
      cout << "Conjoint : inconnu" << endl;
    }
    if (EC.tableP[ind].indParent1 > -1){
      cout << "Parent 1 : " << EC.tableP[EC.tableP[ind].indParent1].nom << endl;
    }
    else{
      cout << "Parent 1 : inconnu" << endl;
    }
    if (EC.tableP[ind].indParent2 > -1){
      cout << "Parent 2 : " << EC.tableP[EC.tableP[ind].indParent2].nom << endl;
    }
    else{
      cout << "Parent 2 : inconnu" << endl;
    }
  }

  else{
    cout << "Cette personne n'est pas dans l'état civil" << endl;
  }
}


void AfficheEtatCivil(EtatCivil EC){
  for(int i = 0; i < EC.nbP; i++){
    cout << "Personne n°" << i+1 << " :" << endl;
    AffichePersonne(i, EC);
    cout << endl;
  }
}

void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}

int TrouvePersonne(string nom, EtatCivil EC){
  for(int i = 0; i < EC.nbP; i++){
    if (nom == EC.tableP[i].nom){
      return i;
    }
  }
  return -1;
}


int main() {
  EtatCivil EC;
  EC.nbP = 0; // il est necessaire d'initialiser le nombre de personnes
  RemplitEtatCivil(EC);
  cout << "Test : AffichePersonne" << endl;
  AffichePersonne(3, EC);
  cout << endl;
  cout << "Test : AfficheEtatCivil" << endl;
  AfficheEtatCivil(EC);
}

```
Anne-laure:
```cpp
void AjoutPersonne (string n, Genre g,int P1,int P2, EtatCivil &EC){
    bool pasErreur=true;
 if (EC.nbP==MAXPERSONNES){
     pasErreur=false;
     cout<<"il y a deja 50 personnes"<<endl;
 }
 for (int i=0; i<EC.nbP; i++){
     if (EC.tableP[i].nom==n){
         pasErreur=false;
         cout<<"quelqu'un porte deja ce nom"<<endl;
     }
 }
    
     if (pasErreur){
     Personne p;
     p.nom= n;
     p.genre= g;
     p.indParent1= P1;
     p.indParent2= P2;
     p.indConjoint=-1;
     EC.tableP[EC.nbP]=p;
     EC.nbP++;
}
}

void AffichePersonne (int indice, EtatCivil EC){
    if (indice> EC.nbP){
        cout<<"cette personne n'est pas dans l'etat civil"<<endl;
    }
    else{
        cout<<"nom: "<<EC.tableP[indice].nom<<endl;
        if (EC.tableP[indice].genre == M){
            cout << "genre: M"<<endl;
        } else{
            cout << "genre: F"<<endl;
        }
        cout << "indice du conjoint : " << EC.tableP[indice].indConjoint << endl;
        cout << "indice du parent 1 : " << EC.tableP[indice].indParent1 << endl;
        cout << "indice du parent 2 : " << EC.tableP[indice].indParent2 << endl;
    }
}

void afficheEtatCivil (EtatCivil EC){
    for(int i=0; i<EC.nbP;i++){
        AffichePersonne (i,EC);
        cout<<endl;
        cout<<endl;
    }
}
void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
 AjoutPersonne("Noemie", F, -1, -1, EC);
 AjoutPersonne("Georges", M, -1, -1, EC);
 AjoutPersonne("Albert", M, -1, -1, EC);
 AjoutPersonne("Marie", F, -1, -1, EC);
 AjoutPersonne("Luc", M, 0, -1, EC);
 AjoutPersonne("Valerie", F, -1, 1, EC);
 AjoutPersonne("Stephane", M, 3, 2, EC);
 AjoutPersonne("Helene", F, 5, 4, EC);
 AjoutPersonne("Justine", F, 7, 6, EC);
 AjoutPersonne("Berenice", F, 5, 10, EC);
 AjoutPersonne("John", M, 12, 11, EC);
 AjoutPersonne("Franco", M, -1, -1, EC);
 AjoutPersonne("Viviane", F, -1, -1, EC);
 AjoutPersonne("Pierre", M, 9, 14, EC);
 AjoutPersonne("Remi", M, 16, 15, EC);
 AjoutPersonne("Boris", M, -1, 17, EC);
 AjoutPersonne("Sharon", F, 19, 18, EC);
 AjoutPersonne("Alexandre", M, -1, -1, EC);
 AjoutPersonne("Augustin", M, -1, -1, EC);
 AjoutPersonne("Johanne", F, -1, -1, EC);
}
int main(){
    EtatCivil EC;
    EC.nbP=0;
    RemplitEtatCivil(EC);
    cout<<"affiche personne 5"<<endl;
    AffichePersonne(5,EC);
    cout<<"affiche Etat civil"<<endl;
    afficheEtatCivil(EC);
}
int CherchePersonne (string nom, EtatCivil EC){
    for (int i=0;i<EC.nbP;i++){
        if(EC.tableP[i].nom== nom){
            return i;
        }
    }
    return -1;
}
ASSERT(CherchePersonne("Stephane",EC)==6);
ASSERT(CherchePersonne("Noemie",EC)==0);
ASSERT(CherchePersonne("Anne",EC)==-1);

bool Mariage (string p1,string p2, EtatCivil &EC){
    int a = CherchePersonne (p1,EC);
    int b= CherchePersonne(p2,EC);
    if (a==-1 or b==-1){
        return false;
    }
    if (EC.tableP[a].indConjoint==-1 and EC.tableP[b].indConjoint==-1){
        EC.tableP[a].indConjoint=b;
        EC.tableP[b].indConjoint=a;
        return true;
    }
    return false;
}

void ArbreGénéalogique (int indice, EtatCivil EC,int tab){
string espace = " "; 
    for (int i = 0; i < tab; i++){  
        espace += " "; 
    }

    if (indice == -1){
        cout <<espace<< "Individu inconnu" << endl;
    } else {
        cout <<espace<< EC.tableP[indice].nom << endl;
        int p1 = EC.tableP[indice].indParent1;
        int p2 = EC.tableP[indice].indParent2;
        ArbreGénéalogique(p1, EC, tab+1);
        ArbreGénéalogique(p2, EC, tab+1);
    }
}

```
Araine:

void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC){
	bool aP = true;
	if(EC.nbP==MAXPERSONNES){
		aP=false;
		cout<<"Le nombre maximum de personnes à été atteint"<<endl;
	}else{
		for(int i=0; i<EC.nbP;i++)
			if(EC.tableP[i].nom==sonNom){
				aP=false;
				cout<<"Quelqu'un porte déjà ce nom"<<endl;
			}
		}	
	if(aP==true){
			EC.tableP[EC.nbP].nom=sonNom;
			EC.tableP[EC.nbP].genre=s;
			EC.tableP[EC.nbP].indConjoint=-1;
			EC.tableP[EC.nbP].indParent1=parent1;
			EC.tableP[EC.nbP].indParent2=parent2;
			EC.nbP++;
			cout<<"Personne rajoutée"<<endl;
    }else{
		cout<<"Ajout impossible"<<endl;
    }
}
void AffichePersonne(int ind, EtatCivil EC){
	for(int i=0; i<EC.nbP; i++){
        if(EC.tableP[ind].nom==EC.tableP[i].nom and EC.tableP[ind].genre==EC.tableP[i].genre and                     EC.tableP[ind].indConjoint==EC.tableP[i].indConjoint and                                                 EC.tableP[ind].indParent1==EC.tableP[i].indParent1 and                                                   EC.tableP[ind].indParent2==EC.tableP[i].indParent2){
			cout<<EC.tableP[ind].nom<<endl;
			cout<<EC.tableP[ind].genre<<endl;
			cout<<EC.tableP[ind].indConjoint<<endl;
			cout<<EC.tableP[ind].indParent1<<endl;
			cout<<EC.tableP[ind].indParent2<<endl;
		}
	}
}
void AfficheEtatCivil(EtatCivil EC){
	for(int i=0; i<EC.nbP; i++){
		AffichePersonne(i, EC);
	}
}
void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  Ajovoid RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}
int main() {
    EtatCivil EC;
    EC.nbP = 0; // il est necessaire d'initialiser le nombre de personnes
    RemplitEtatCivil(EC);
    AfficheEtatCivil(EC);
    return 0;
}

```cpp
Romain : 
```cpp

#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;

const int MAXPERSONNES = 50;

enum Genre { M, F };

struct Personne{
  string nom;
  Genre genre;
  int indConjoint, indParent1, indParent2;
};

struct EtatCivil {
   Personne tableP[MAXPERSONNES];
   int nbP;
};

void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC);
void AffichePersonne(int ind, EtatCivil EC);
void AfficheEtatCivil(EtatCivil EC);

void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}

void AjoutPersonne(string nom, Genre s, int parent1, int parent2, EtatCivil &EC) {
    bool b = true;
    if (EC.nbP == MAXPERSONNES) {
        b = false;
        cout << "L'etat civil est plein." << endl;
    } else {
        for (int i = 0; i < EC.nbP; i++)
            if (EC.tableP[i].nom == nom) {
                b = false;
                cout << "La personne " << nom << " existe deja." << endl;
                return;
            }
        if (b == true) {
            EC.tableP[EC.nbP].nom = nom;
            EC.tableP[EC.nbP].genre = s;
            EC.tableP[EC.nbP].indConjoint = -1;
            EC.tableP[EC.nbP].indParent1 = parent1;
            EC.tableP[EC.nbP].indParent2 = parent2;
            EC.nbP++;
        }
    }
}

void AffichePersonne(int i, EtatCivil EC) {
    if (i >= EC.nbP) {
        cout << "La personne d’indice " << i << " n’existe pas." << endl;
    } else {
        cout << "Individu " << i << endl;
        cout << "Nom : " << EC.tableP[i].nom << endl;
        cout << "Genre : ";
        if (EC.tableP[i].genre == M)cout << "Masculin" << endl;
        else cout << "Feminin" << endl;
        if (EC.tableP[i].indConjoint == -1)
            cout << "Célibataire" << endl;
        else cout << "Conjoint: " << EC.tableP[i].indConjoint << endl;
        cout << "Parents : " << EC.tableP[i].indParent1 << ", " << EC.tableP[i].indParent2 << endl << endl;
    }
}

void AfficheEtatCivil(EtatCivil EC) {
    int i;
    for(i=0; i<EC.nbP; i++) AffichePersonne(i, EC);
}

int RecherchePersonne(string nom, EtatCivil EC) {
    for (int i = 0; i < EC.nbP; i++)
        if (EC.tableP[i].nom == nom) return i;
    return -1;
}

void AfficheArbreGenePersonneAux(int individu, EtatCivil EC, int generation) {
    cout << "Individu ";
    if (individu == -1) cout << "inconnu" << endl;
    else {
        cout << individu << endl;
        for (int i=0; i < generation; i++)
            cout << "   ";
        AfficheArbreGenePersonneAux(EC.tableP[individu].indParent1, EC, generation+1);
        for (int i=0; i < generation; i++)
            cout << "   ";
        AfficheArbreGenePersonneAux(EC.tableP[individu].indParent2, EC, generation+1);
    }
}

void AfficheArbreGenePersonne(int individu, EtatCivil EC) {
    int generation = 1;
    if (individu >= EC.nbP)cout << "La personne d’indice " << individu << " n’existe pas." << endl;
    else AfficheArbreGenePersonneAux(individu, EC, generation);
}
bool Mariage(string nom1, string nom2, EtatCivil &EC) {
    int i1, i2;
    i1 = RecherchePersonne(nom1, EC);
    i2 = RecherchePersonne(nom2, EC);
    if (i1 == -1 || i2 == -1 || EC.tableP[i1].indConjoint != -1 || EC.tableP[i2].indConjoint != -1)return false;
    EC.tableP[i1].indConjoint = i2;
    EC.tableP[i2].indConjoint = i1;
    return true;
}

int main() {
    EtatCivil EC;
    EC.nbP = 0;
    RemplitEtatCivil(EC);

    AjoutPersonne("Dark Vador", M, -1, -1, EC);
    AjoutPersonne("Padme", F, -1, -1, EC);

    AffichePersonne(0, EC);
    AffichePersonne(1, EC);
    AffichePersonne(2, EC);

    AfficheEtatCivil(EC);

    cout << "Personne Dark Vador: " << RecherchePersonne("Dark Vador", EC) << endl;
    cout << "Personne Yoda: " << RecherchePersonne("Yoda", EC) << endl;

    bool mariage = Mariage("Dark Vador", "Padme", EC);
    cout << "Mariage Dark Vador et Padme : ";
    if (mariage)cout << "possible" << endl;
    else cout << "impossible";

    AfficheArbreGenePersonne(9, EC);

    return 0;
}
```

Doriane:
```cpp
const int MAXPERSONNES = 50;

enum Genre { M, F };

struct Personne{
  string nom;
  Genre genre;
  int indConjoint, indParent1, indParent2;
};

struct EtatCivil {
   Personne tableP[MAXPERSONNES];
   int nbP;
};

void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC);
void AffichePersonne(int ind, EtatCivil EC);
void AfficheEtatCivil(EtatCivil EC);


void AjoutPersonne(string sonNom, Genre s, int parent1, int parent2, EtatCivil &EC){
	int indice;
	bool ajout=true;
	if (EC.nbP==MAXPERSONNES){
		ajout=false;
		cout<<"déso, on rajoute personne, la base est pleine"<<endl;
	}
	else{
		for(int i = 0; i<EC.nbP; i++){
			if (EC.tableP[i].nom==sonNom){
				ajout=false;
				cout<<"déso, ce nom est déja pris, on le rajoute pas à la base"<<endl;
			}
		}
	}
	if(ajout==true) {
		indice=EC.nbP;
		EC.tableP[indice].nom = sonNom;
		EC.tableP[indice].genre = s;
		EC.tableP[indice].indConjoint=-1;
		EC.tableP[indice].indParent1 = parent1;
		EC.tableP[indice].indParent2 = parent2;
		EC.nbP++;
	}
	
}

void AffichePersonne(int ind, EtatCivil EC){
	if(EC.nbP<ind+1){
		cout<<"déso, cette personne n'existe pas"<<endl;
	}
	else{
		cout<<"Son nom est "<<EC.tableP[ind].nom<<endl;
		
		if(EC.tableP[ind].genre==M){
			cout<<"Genre : Masculin"<<endl;
			
		}
		else{
			cout<<"Genre : Féminin"<<endl;
		}
		if (0<=EC.tableP[ind].indConjoint<=EC.nbP){
			cout<<"Son conjoint s'appelle "<<EC.tableP[EC.tableP[ind].indConjoint].nom<<endl;
		}
		else{
			cout<<"Cette personne n'est pas mariée"<<endl;
		}
		if (0<=EC.tableP[ind].indParent1<=EC.nbP){
			cout<<"Un de ses parent s'appelle "<<EC.tableP[EC.tableP[ind].indParent1].nom<<endl;
		}
		if(0<=EC.tableP[ind].indParent2<=EC.nbP){
			cout<<"Un de ses parent s'appelle "<<EC.tableP[EC.tableP[ind].indParent2].nom<<endl;
		}
	}
}


void AfficheEtatCivil(EtatCivil EC){
	for(int i = 0; i<EC.nbP;i++){
		cout<<EC.tableP[i].nom<<endl;
		cout<<endl;
	}
}



void RemplitEtatCivil(EtatCivil &EC) { // remplit l'état civil avec 20 personnes
  AjoutPersonne("Noemie", F, -1, -1, EC);
  AjoutPersonne("Georges", M, -1, -1, EC);
  AjoutPersonne("Albert", M, -1, -1, EC);
  AjoutPersonne("Marie", F, -1, -1, EC);
  AjoutPersonne("Luc", M, 0, -1, EC);
  AjoutPersonne("Valerie", F, -1, 1, EC);
  AjoutPersonne("Stephane", M, 3, 2, EC);
  AjoutPersonne("Helene", F, 5, 4, EC);
  AjoutPersonne("Justine", F, 7, 6, EC);
  AjoutPersonne("Berenice", F, 5, 10, EC);
  AjoutPersonne("John", M, 12, 11, EC);
  AjoutPersonne("Franco", M, -1, -1, EC);
  AjoutPersonne("Viviane", F, -1, -1, EC);
  AjoutPersonne("Pierre", M, 9, 14, EC);
  AjoutPersonne("Remi", M, 16, 15, EC);
  AjoutPersonne("Boris", M, -1, 17, EC);
  AjoutPersonne("Sharon", F, 19, 18, EC);
  AjoutPersonne("Alexandre", M, -1, -1, EC);
  AjoutPersonne("Augustin", M, -1, -1, EC);
  AjoutPersonne("Johanne", F, -1, -1, EC);
}


int Cherche(string sonNom, EtatCivil EC){
	for(int i=0; i<MAXPERSONNES;i++){
		if (sonNom==EC.tableP[i].nom){
			return i;
		}
	}
	return -1;
}

bool mariage(string nom1, string nom2, EtatCivil EC){
	int ind1;
	int ind2;
	ind1=Cherche(nom1, EC);
	ind2=Cherche(nom2, EC);
	if(ind1==-1 or ind2==-1){
		return false;
	}
	else{
		if(0<=EC.tableP[ind1].indConjoint<=EC.nbP or 0<=EC.tableP[ind2].indConjoint<=EC.nbP){
			return false;
		}
		EC.tableP[ind1].indConjoint=ind2;
		EC.tableP[ind2].indConjoint=ind1;
		return true;
	}
}


void arbre(int indice, EtatCivil EC){
	cout<<"individu   ";
	if (indice<0 or indice>EC.nbP) {
		cout<<"inconnu"<<endl;
	}
	else {
		cout<<indice<<endl;												//si la personne existe, on met son indice
		cout<<"    individu  ";
		if(EC.tableP[indice].indParent1<0 or EC.tableP[indice].indParent1>EC.nbP){
			cout<<"inconnu"<<endl;										//dans le cas ou on ne connais pas sa mere.
		}
		else{															//on regarde si elle a une mere
			cout<<EC.tableP[indice].indParent1<<endl;
			cout<<"    ";
			cout<<"    individu";
			if(EC.tableP[EC.tableP[indice].indParent1].indParent1!=-1){	//on regarde si elle a une grand mere du coté de la mere
				cout<<"  "<<EC.tableP[EC.tableP[indice].indParent1].indParent1<<endl;
			}
			else{
				cout<<"  inconnu"<<endl;
			}
			cout<<"    ";
			cout<<"    individu";
			
			if (EC.tableP[EC.tableP[indice].indParent1].indParent2==-1){
				cout<<"  inconnu"<<endl;
			}
			
			else{														//on regarde si elle a un grand pere du cote de la mere
				cout<<"  "<<EC.tableP[EC.tableP[indice].indParent1].indParent2<<endl;
			}
						
		}
		
		if(EC.tableP[indice].indParent2!=-1){							//on regarde si elle a un pere
			cout<<"    ";
			cout<<"individu   "<<EC.tableP[indice].indParent2<<endl;
			cout<<"    ";
			cout<<"    individu";
			if(EC.tableP[EC.tableP[indice].indParent2].indParent1!=-1){	//on regarde si elle a une grand mere du coté du pere
				cout<<"  "<<EC.tableP[EC.tableP[indice].indParent2].indParent1<<endl;
			}
			else{
				cout<<"  inconnu"<<endl;
			}
			cout<<"    ";
			cout<<"    individu";
			if(EC.tableP[EC.tableP[indice].indParent2].indParent2!=-1){	//on regarde si elle a un grand pere du cote du pere
				cout<<"  "<<EC.tableP[EC.tableP[indice].indParent2].indParent2<<endl;
			}
			else{
				cout<<"  inconnu"<<endl;
			}			
		}
		else{
			cout<<"    ";
			cout<<"individu";
			cout<<"  inconnu"<<endl;										//dans le cas ou on ne connais pas son pere.
		}
	}
	
}
	


int main() {
  EtatCivil EC;
  EC.nbP = 0; // il est necessaire d'initialiser le nombre de personnes
  RemplitEtatCivil(EC);
  AfficheEtatCivil(EC);
  int pnj;
  cout<<"indice?"<<endl;
  cin>>pnj;
  arbre(pnj, EC);
  return 0;
}
```
