#ifndef TABLEAU_H
#define TABLEAU_H

#include <cstddef>
#include "math.h"

using namespace std;

template <typename TYPE>
class Tableau
{
private:
    size_t taille;
    TYPE* tab;

	//supprime la mémiore pointée par tab et le met à nullptr
    void nettoyer();


public:
    Tableau();
	
	//créé un tableau de taille n avec contenu non-initialisé
    Tableau(size_t n);
	
    Tableau(const Tableau& src);

    ~Tableau();


    Tableau& operator=(const Tableau& src);

    void redimensionner(size_t n);


    size_t size();
	
    TYPE& operator[](size_t i);

};




//////////////////////
// IMPLÉMENTATION
//////////////////////
template <typename TYPE>
Tableau<TYPE>::Tableau()
{
    tab = nullptr;
    taille = 0;
}

template <typename TYPE>
Tableau<TYPE>::Tableau(size_t n)
{
    //déléguer la création vers redimensionner
    //pour que ça fonctionne, il faut s'assurer d'avoir tab = nullptr
    tab = nullptr;
    redimensionner(n);
}


template <typename TYPE>
Tableau<TYPE>::Tableau(const Tableau &src)
{
    tab = nullptr;
    (*this) = src;
}




template <typename TYPE>
Tableau<TYPE>::~Tableau()
{
    nettoyer();
}


template <typename TYPE>
void Tableau<TYPE>::redimensionner(size_t n)
{
    TYPE* temp = new TYPE[n];   

    //copier les elements qui doivent rester dans le tableau, s'il y a lieu
    if (tab)
    {
        for (size_t i = 0; i < min(taille, n); i++)
        {
            temp[i] = tab[i];
        }

        nettoyer();	//suppression du tab original
    }

    taille = n;
    tab = temp;

}



template <typename T>
Tableau<T>& Tableau<T>::operator=(const Tableau& src)
{
    //tab = src.tab;  //A NE SURTOUT PAS FAIRE: CECI NE COPIERAIT QUE LE POINTEUR, PAS SON CONTENU
    taille = src.taille;

    nettoyer();

    tab = new T[src.taille];

    for (size_t i = 0; i < taille; i++)
    {
        tab[i] = src.tab[i];
    }
	
	return *this;
}




//pas fait en classe
template <typename TYPE>
void Tableau<TYPE>::nettoyer()
{
    if (tab)
    {
        delete [] tab;
        tab = nullptr;
    }
}


template <typename TYPE>
size_t Tableau<TYPE>::size()
{
    return taille;
}


template <typename TYPE>
TYPE& Tableau<TYPE>::operator[](size_t i)
{
    //note: pas notre problème de vérifier les bornes
    return tab[i];
}



#endif