ex3.cpp

#include <iostream>
#include <string> //permet l'utilisation du type string.
using namespace std;
/*
Auger-Dubois Benoit et Attala Fadia groupe 385K
*/

/* Nous allons utilisé le type string plutôt que le tableau de caractères
pour pouvoir utiliser la fonction getline, 
et ainsi pouvoir utiliser des espaces lors d'une saisie */

struct T_date {
    // structure représentant une date sous la forme JJ/MM:AAAA.
    // les type string sont plus simple que les entiers pour l'affichage.
    string jour; 
    string mois;
    string annee; 
};

struct T_personne {
    // structure qui représente une personne
    string nom; 
    string prenom;
    T_date naiss; // date de naissance de la forme T_date définie au dessus.
    string age; // les type string sont plus simple que les entiers pour l'affichage.
    string adresse; // adresse de la personne
};

/* Permet l'affichage des informations d'une structure T_personne 
en utilisant un pointeur de type t_personne en entrée. */
void affPers2(T_personne* pers){
    cout << "nom,prenom : " << pers->nom << " " << pers->prenom << endl 
    << "date de naissance : " << pers->naiss.jour << "/" 
    << pers->naiss.mois << "/" << pers->naiss.annee << endl
    << "age : " << pers->age << endl
    << "adresse : " << pers->adresse << endl;
}


/* Procédure de saisie d'un T_personne.
Avantage par rapport a une fonction : moins long, pas besoin de crée une nouvelle variable,
pas besoin de cloné les données car pers est en modification.
Donc on as moins de coût mémoirs et de temps d'éxécution. 
Désaventage : efface les valeurs précedemment stocké dans le T_personne. */

void saisieP (T_personne &pers){
    cout << "entre le nom de la personne : ";
    getline (cin,pers.nom); // getline permet d'utiliser des espaces lors d'une saisie
    cout << "entre le prenom de la personne : ";
    getline (cin,pers.prenom);
    cout << "entrer l'adresse de la personne : ";
    getline (cin,pers.adresse);
    cout << "entrer l'age de la personne : ";
    getline (cin,pers.age);
    cout << "entrer l'année de naissance : ";
    getline (cin,pers.naiss.annee);
    cout << "entrer le mois de naissance : ";
    getline (cin,pers.naiss.mois);
    cout << "entrer le jour de naissance : ";
    getline (cin,pers.naiss.jour);
}


/* 
Le pointeur vers un T_personne est utile si il faut changer de binome pour ne pas avoir a réecrire
toutes les champs du T_personne.
Le T_personne est moins ergonomique si les binomes change au cours du temps pour la raison cités plus haut.
*/
struct T_binome
{
    // structure définissant un binôme composé de 2 T_personne
    T_personne* etu1;
    T_personne* etu2;
    bool isBinome; /* si les deux pointeurs sont affectés a des addresses différentes
    isBinome est vrai sinon il est faux. */
};


/* les différents scenario sont pris en compte en amont lors 
de l'affectation du booleen isBinome comme préciser dans le T_binome*/

/*
Cette procédure affiche succinctement les 2 personnes d'un binome.
*/
void affBSuccinct(T_binome b){
    if (b.isBinome){
        cout << b.etu1->nom << " " << b.etu1->prenom << " est en binome avec : " << 
        b.etu2->nom << " " << b.etu2->prenom << endl; 
    }else{
        cout << "Le binome est incorrect"; // cas d'erreur.
    }
}

/*
Cette procédure affiche les 2 personnes d'un binome avec toutes leurs informations.
*/
void affBComplet(T_binome b){
    if (b.isBinome){
        affPers2(b.etu1);
        cout << endl << "est en binome avec : " << endl;
        affPers2(b.etu2);
    }else{
        cout << "Le binome est incorrect"; // cas d'erreur.
    }
}


/*
Cette procédure crée un binôme avec 2 personne en entrée.
P1 et P2 en modification pour économiser de la mémoirs et 
éviter tous conflits.
*/
void addB(T_personne &P1, T_personne &P2,T_binome &B){
    B.etu1 = &P1;
    B.etu2 = &P2;
    if (&P1 != &P2){
    B.isBinome = true;
    } else {
        cout << "Entrer différents étudiants"; //cas d'erreur.
    }
}

/*
Cette fonction retourne un binome en fonction des 2 pointeurs
T_personne en entrée
*/
T_binome addB2(T_personne* P1, T_personne* P2){
    T_binome B;
    B.etu1 = P1;
    B.etu2 = P2;
    if (P1 != P2){
    B.isBinome = true;
    } else {
        cout << "Entrer différents étudiants";
    }
    return B;
}

/*
Crée un T_binome et 2 T_personne puis demande a l'utilisateur de saisir les champs
des T_personne a l'aide de la procédure SaisieP(), crée le binome a l'aide de la fonction addB2()
puis l'affiche avec la procédure affBsuccinct()
*/
int main () {
    T_binome B;
    T_personne etu1,etu2;
    saisieP(etu1),saisieP(etu2);
    B = addB2(&etu1,&etu2); // addB(etu1,etu2,B); alternative
    affBSuccinct(B); // affBcomplet(B); alternative
}