#if !defined(_TABLEAU___H_)
#define _TABLEAU___H_

#include <assert.h>

template <class T>
class Tableau{

  public:
    Tableau(int capacite_initiale=4);
    Tableau(const Tableau&);
    ~Tableau();

    // Ajouter un element à la fin
    void           ajouter(const T& element);
    // Vider le tableau
    void           vider();
    // Retourne le nombre d'éléments dans le tableau
    int            taille() const;

    // Insère element à position index. Les éléments à partir de index sont décalés d'une position.
    void           inserer(const T& element, int index=0);

    // Enlève l'element à position index. Les éléments après index sont décalés d'une position après.
    void           enlever(int index=0);

    // Cherche et retourne la position de l'élément. Si non trouvé, retourne -1.
    int            chercher(const T& element);

    const T&       operator[] (int index) const;
    T&             operator[] (int index);

    bool           operator == (const Tableau<T>& autre) const;
    Tableau<T>&    operator = (const Tableau<T>& autre);

  private:
    T*             elements;
    int            nbElements;
    int            capacite;
};


// ---------- Définitions -------------


template <class T>
Tableau<T>::Tableau(int capacite_)
{
    capacite = capacite_;
    nbElements = 0;
    elements = new T[capacite]; 
}

template <class T>
Tableau<T>::Tableau(const Tableau& autre)
{
    capacite = autre.capacite ;
    elements = new T[capacite];
    nbElements = autre.nbElements;
   for (int i = 0; i < nbElements; i++){
        elements[i] = autre.elements[i] ;
    }

    
}

template <class T>
Tableau<T>::~Tableau()
{
    delete[] elements;
}

template <class T>
int Tableau<T>::taille() const
{
    return nbElements;
    
}

template <class T>
void Tableau<T>::ajouter(const T& item)
{
    if(nbElements==capacite){               //si le tableau est plein
        capacite *= 2;                      //on double la capacité
        T* nouveautab = new T[capacite];    //on crée un nouveau tableau avec cette capacité
        for (int i=0; i < nbElements; i++){ //on copie tous les éléments de l'ancien tableau
            nouveautab[i] = elements[i];    
        }
        delete[] elements;                   //on supprime le tableau obsolète
        elements = nouveautab;               //on pointe vers le nouveau tableau
    }    
   elements[nbElements++]=item;              // on ajoute notre élément a la fin tout en incrémentant notre compteur
}

template <class T>
void Tableau<T>::inserer(const T& element, int index)
{
    // À compléter
    if(nbElements==capacite){               //si le tableau est plein
        capacite *= 2;                      //on double la capacité
        T* nouveautab = new T[capacite];    //on crée un nouveau tableau avec cette capacité
        for (int i=0; i < nbElements; i++){ //on copie tous les éléments de l'ancien tableau
            nouveautab[i] = elements[i];    
        }
        delete[] elements;                   //on supprime le tableau obsolète
        elements = nouveautab;               //on pointe vers le nouveau tableau
    }    


    for (int i = nbElements; i >= index; i--){  // en partant du dernier élément puis en descendant
        
            elements[i+1] = elements[i];       //on remplace l'élément par son précédent
        
     }
    elements[index] = element;                  //une fois arrivée à la valeur index on ajoute l'élément demandé 
    nbElements++;                               //on incrémente le nbr d'élément

}

template <class T>
void Tableau<T>::enlever(int index)
{
    //À compléter
    
    for (int i = index; i < nbElements; i++){               //en partant de l'élément à retirer
        
            elements[i] = elements[i+1];                    //on remplace tous les éléments par leur suivant jusqu'à arriver au dernier
        
     }
    elements[nbElements]=0;                                 //on remplace le dernier par un 0 
    nbElements--;                                           //on décrément le nombre d'éléments
}

template <class T>
int Tableau<T>::chercher(const T& element)
{
    int i;                              
    for(i = 0; i < nbElements ; i++){           // on parcours le tableau entierement
        if(elements[i] == element)              //si on trouve notre élément on s'arrete
        {
           return i;
        }
    }
    return -1;                                  //sinon on renvoie -1
}

template <class T>
void Tableau<T>::vider()
{
    while(nbElements > 0){                      //tant que le nombre d'élément n'est pas a 0 
        elements[nbElements] = 0 ;              //on remplace l'élément actuel par 0
        nbElements--;                           // on décrémente le nombre d'élément
    }
}

template <class T>
const T& Tableau<T>::operator[] (int index) const
{
    assert(index<nbElements);
    return elements[index];
}

template <class T>
T& Tableau<T>::operator[] (int index)
{
    assert(index >= 0 && index<nbElements);
    return elements[index];
}

template <class T>
Tableau<T>& Tableau<T>::operator = (const Tableau<T>& autre)
{
        if(elements == autre.elements)      //si les deux tableaux sont déjà identiques pas besoin de le copier
                return *this;
    nbElements = autre.nbElements;          //sinon on copie le nopmbre d'élément
    if(capacite < autre.nbElements){        //on vérifie que les deux tableau ont la meme capacité, le cas échéant on corrige
        delete[] elements;
        capacite = autre.capacite; 
        elements = new T[capacite];
    }
    for(int i=0;i < nbElements;i++)         //on copie les éléments un a un
        elements[i] = autre.elements[i];
    return *this;
}

template <class T>
bool Tableau<T>::operator == (const Tableau<T>& autre) const
{
    int k,p;
    k = nbElements;
    p = autre.taille();
    if(k == p){                                              //on vérifie que les deux tableaux font la meme taille
        for (int i = 0; i< k; i++){
            if (elements[i]!= autre.elements[i]){               //on vérifie que les éléments sont égaux un a un
                return false;
            }
        }
         return true;
    }
    else
    return false;
}

#endif //define _TABLEAU___H_

#if !defined(_CHAINE__H_)
#define _CHAINE__H_

#include <iostream>
#include "tableau.h"

using namespace std;

// Représente une chaine de caractaires
class Chaine{
  public:
    
    // Interface publique ici.
    Chaine(int _taille); //ici j'ai ajouté cette ligne sorti di fichier d'aide du prof 
    Chaine(const Chaine& chaine);
	~Chaine();
    
  private:
    // Représentation ici.
    
    
    Tableau<char> mot; // ici j'ai ajouté cette ligne et mis en commentaire les deux suivantes.
    //char  mot[50]; //Vous devrez avoir un tableau dynamique générique
    //int taille;	//optionnel, car vous pouvez utiliser celui de votre tableau générique

    friend ostream& operator << (ostream& os, const Chaine& chaine);
    friend istream& operator >> (istream &is, Chaine &m);
    Chaine  operator = (const Chaine);

};


#endif

#include "chaine.h"



Chaine::Chaine(int _taille) 
{
    mot = new Tableau<char>(_taille); // ça ça ne fonctionne pas

}

Chaine::Chaine(const Chaine& chaine) //constructeur par copie
{
    mot = chaine.mot;
}

Chaine::~Chaine()
{
    mot.vider();
}


ostream& operator << (ostream& os, const Chaine& chaine)
{
    for (int i = 0; i <chaine.mot.taille(); i++)
	{
		cout << chaine.mot[i] << endl;
	}
    return os;
}

istream& operator >> (istream &is, Chaine &m)
{
	char c; 
	while ((is.get(c)) && (c != '\n'))
	{
		m.mot.ajouter(c) ; //L'opérateur [] doit être surchargé aussi 
	}

	return is;
}