#include<iostream>
#include<math.h>
#include<string>
#include <stdlib.h>
#include <vector>

using namespace std;

// Classe mère abstraite Forme qui va donner 3 filles: carré, rectangle, cercle
class Forme
{
    public:
        //définitions des fonctions de la classe abstraite
        virtual double perimetre()=0;
        virtual double aire()=0;
        virtual void afficher()=0;
        virtual ~Forme(){};
};


//------------------ Carré ------------
//Classe dille de Forme, définie par son coté
class carre:public Forme{
protected:
    double cote;
public:
    //Constructeur
    carre(double);
    //fonctions, qui renvoient le perimetre, l'air et les propriétés d'un carré
    virtual double perimetre();
    virtual double aire();
    virtual void afficher();
    //Destructeur
    virtual ~carre();
};

carre::carre(double a){cote=a;}
double carre::perimetre(){return(4*cote);}
double carre::aire(){return(pow(cote,2));}

void carre::afficher()
{
    cout<<"--------------------------"<<endl;
    cout<<"Forme : Carre"<<endl;
    cout<<"--------------------------"<<endl;
    cout<<"- Son cote : "<<cote<<endl;
    cout<<"- Son perimetre : "<<4*cote<<endl;
    cout<<"- Son aire : "<<cote*cote<<endl;
    cout<<"--------------------------"<<endl<<endl;
}
carre::~carre(){}

//----------------------- Rectangle ------------------------
//On définie la classe rectangle qui est fille de carre et qui est définie par sa largeur (coté du carré) et sa longueur
class rectangle:public carre{

protected:
    float longueur;

public:
    //constructeur
    rectangle(float ,float);
    //fonctions, qui renvoient le perimetre, l'air et les propriétés d'un rectangle
    virtual double perimetre();
    virtual double aire();
    virtual void afficher();
    //destructeur
    virtual ~rectangle();
};

rectangle::rectangle(float v1,float v2):carre(v1){longueur = v2;}
double rectangle::perimetre(){return(2*cote + 2*longueur);}
double rectangle::aire(){return(cote*longueur);}
rectangle::~rectangle(){}

void rectangle::afficher()
{
    cout<<"--------------------------"<<endl;
    cout<<"Forme : Rectangle"<<endl;
    cout<<"--------------------------"<<endl;
    cout<<"- Sa largeur : "<<cote<<endl;
    cout<<"- Sa longeur : "<<longueur<<endl;
    cout<<"- Son perimetre : "<<2*cote+2*longueur<<endl;
    cout<<"- Son aire : "<<longueur*cote<<endl;
    cout<<"--------------------------"<<endl<<endl;
}
// ---------- Cercle ----------
//On définie la classe cercle qui est fille de carre et qui est définie par son rayon (coté du carré)
class cercle:public carre{

public:
    //Constructeur
    cercle(float);
    //fonctions, qui renvoient le perimetre, l'air et les propriétés d'un cercle
    virtual double perimetre();
    virtual double aire();
    virtual void afficher();
    //destructeur
    virtual ~cercle();
};

cercle::cercle(float v1):carre(v1){}
double cercle::perimetre(){return(2*M_PI*cote);}
double cercle::aire(){return(M_PI*cote*cote);} //M_PI est égale a pi dans la bibliotheque <stdlib.h>
cercle::~cercle(){}

void cercle::afficher()
{
    cout<<"--------------------------"<<endl;
    cout<<"Forme : Cercle"<<endl;
    cout<<"--------------------------"<<endl;
    cout<<"- Son rayon : "<<cote<<endl;
    cout<<"- Son perimetre : "<<2*M_PI*cote<<endl;
    cout<<"- Son aire : "<<M_PI*cote*cote<<endl;
    cout<<"--------------------------"<<endl<<endl;
}
void afficher_forme(carre * f){f->afficher();}
void afficher_forme(rectangle * f){f->afficher();}
void afficher_forme(cercle * f){f->afficher();}


// ------- Main pour tester les fonction

/*
main()
{
    carre c(3);
    rectangle r(3,4);
    cercle ce(4);
    afficher_forme(&c);
    afficher_forme(&r);
    afficher_forme(&ce);

    Forme * f1 = new carre (5);
    f1->afficher();

    Forme * f2 = new rectangle(6,7);
    f2->afficher();

    Forme * f3 = new cercle(3);
    f3->afficher();
}
*/
int saisir_n() //Saisir un entier en utilisant les pointeurs
{   int n;
    do{
        cout<<"Quelle est la taille du tableau a ajouter: ";
        cin>>n;
    }while(n<0);
    return(n);
}

void saisir(Forme *t, int a, int b) //Fonction qui propose de saisir un tableau de Forme de tailles b-a
{
    float d,e; //les paramètres des
    int k; //choix de la forme
    int i;

    for (i=a;i<b;i++)
    {
        do{
        cout<<"Pour le "<<i+1<< "ieme element du tableau, voulez vous saisir:"<<endl<<"   1 - Un carre"<<endl<<"   2 - Un rectangle"<<endl<<   "   3 - Un cercle";

        cin>>k;
        if (k==1){cout<<"Entrer le cote du carre a ajouter: ";cin>>d;t[i]=carre(d);cout<<endl;}
        if (k==2){cout<<"Entrer la largeur du rectangle a ajouter: ";cin>>d;cout<<"Entrer la longueur du rectangle a ajouter: ";cin>>e;t[i]=rectangle(d,e);}
        if (k==3){cout<<"Entrer le rayon du cercle a ajouter: ";cin>>d;t[i]=cercle(d);}

        }while(k!=1 && k!=2 && k!=3);
    }
}


void afficher(Forme *t, int n) //Affiche les n premières valeurs d'un tableau t
{
    int i;
    for (i=0;i<n;i++)
    {
       t[i].afficher(); //affiche le tableau élément par élément
    }
}

main()
{   int choix; //Choix que l'utilisateur va faire entre 1,2,3 dans le menu
    int n; // taille du tableau à ajouter au tableau précédent
    int N=0; //taille totale du tableau au cours du temps
    Forme *t=NULL; //Initialisation du tableau
    do
        {
            cout<<endl<<"################################################## Menu ##################################################"<<endl;
            cout<<"                                         1 - Saisir des formes "<<endl;
            cout<<"                                         2 - Afficher le tableau "<<endl;
            cout<<"                                         3 - Quitter"<<endl;
            cout<<"##########################################################################################################";
            cin>>choix;

            if(choix==1)
            {
                n=saisir_n();
                if(N==0)
                {
                    t=(Forme*)malloc(n*sizeof(Forme)); //Création du tableau t en allouant la mémoire suffisante
                    cout<<endl<<"Saisir les elements du tableau:"<<endl;
                }
                else
                {
                    t=(Forme*)realloc(t,(N+n)*sizeof(Forme));//On réallou de la mémoire au tableau t
                    cout<<endl<<"Saisir la suite du tableau:"<<endl;
                }

                saisir(t,N,n+N);
                N=n+N; //On met a jour la taille du tableau
            }
            if(choix==2)
            {
                if(t==NULL)
                {
                    cout<<"Veuillez d'abord appuyer sur 1"<<endl;
                }
                else
                {
                    cout<<"Le tableau en memoire est:"<<endl;
                    afficher(t,N);
                    cout<<endl;
                }
            }
            if(choix==3){exit(0);}

        }while(choix!=1 || choix!=2 || choix!=3);
    free(t);
    cout<<endl<<"##################################################  FIN  ##################################################"<<endl;
}