//
//  TabEnt.cpp
//  TableauEntier
//
//  Created by vlaurain on 30/01/2020.
//  Copyright © 2020 vlaurain. All rights reserved.
//

#include "TabEnt.hpp"


//=======Constructeurs
TabEnt::TabEnt(int t, int v)
{
    int i;
    if (t>0)
    {taille=t;
        ptr= new int[taille]; //allocation
        for(i=0;i<taille;i++)  //remplissage
        {
            *(ptr+i)=v;
        }
    }
    else
    {
        cout<<"la taille doit être positive"<<endl;
        taille=0;
        ptr=0;
    }
    
}

//Le constructeur par recopie sera le constructeur qui sera utilisé lorsqu'on
// effectuera la ligne suivante dans le main:
// Tabent t=e; ( ou e est un autre TabEnt)

TabEnt::TabEnt(TabEnt & Autre)
{
    int i;
    taille=Autre.taille;
    ptr= new int[taille];
    for(i=0;i<taille;i++)
    {
        *(ptr+i)=*(Autre.ptr+i);
    }
    
}



//Affichage
void TabEnt::Affiche()
{
    for(int i=0;i<taille;i++)
    {
        cout<< *(ptr+i)<<",";
    }
    cout<<endl;
}

//  mettre une valeur à une position donnée
void TabEnt::set_value(int pos, int v)
{
    if (pos<taille && pos>0)
    {
        *(ptr+pos)=v;
    }
    else{
        cout<<"position inexistante"<<endl;
    }
    
}


//Rallonger le tableau
void TabEnt::Rallonge(int n, int v)
{   int i;
    int * dummy;
    if (n>0)
    {
        dummy=new int[taille+n]; //réalloue à la bonne taille
        for(i=0;i<taille;i++)  //recopie les anciennes valeurs
        { *(dummy+i)=*(ptr+i);}
        for(i=taille;i<taille+n;i++) //met la nouvelle valeur
        { *(dummy+i)=v;}
        if (ptr!=0)
        {delete [] ptr;}  //desalloue l'ancien pointeur
        ptr=dummy;   // replace le nouveau pointeur
        taille=taille+n; //remet à la bonne taille
    }
    else{ cout<< "le nombre de cases à ajouter doit être positif"<<endl;}
    
}



//Surcharge de l'operateur +, pour pouvoir faire a+b lorsque a et b sont des tableaux
TabEnt TabEnt::operator+( TabEnt &Autre)
{int i;
    TabEnt res(taille+Autre.taille);  //le resultat qui sera renvoyé en faisant par exemple a=b+c
    for(i=0;i<taille;i++)
    {*(res.ptr+i)=*(ptr+i);}
    for(i=taille;i<taille+Autre.taille;i++)
    {*(res.ptr+i)=*(Autre.ptr+i-taille);}
    return(res);
    
}


//La surcharge de l'opérateur = est vraiment particulière.
//Lorsqu'on tape a=b, il faut lire a.operateur=(b);
//On ne devrait rien renvoyer, mais puisqu'il y a le signe = il faut quand même renvoyer quelque chose
//Dans ce cas on se renvoie soi-même
//On peut apprendre par coeur cette structure sans vraiment la comprendre.
//Le const est important il signifie que la variable Autre sera non modifiée

TabEnt& TabEnt::operator=( const TabEnt& Autre)
{
    if(this!=&Autre)   //On vérifie qu'on ne se copie pas dans soi-même
    {
      taille=Autre.taille;
      if (ptr!=0)    //on pense à désallouer ptr si l'objet existait déja
        {delete [] ptr;}
     ptr= new int[taille];//on réalloue alloue le tableau
     for(int i=0;i<taille;i++)//on recopie élément par élément le tableau
     {
        *(ptr+i)=*(Autre.ptr+i);
     }
    }
    return *this;//On retourne l'objet lui même où this est un pointeur sur l'objet lui même
    
}



//destructeur
TabEnt:: ~TabEnt(){
    if(ptr!=0)
    {delete [] ptr;}
    cout<<" destruction"<<endl; //ceci n'est pas nécessaire mais vous permettra de voir ce qui se passe à l'execution
}