#include <iostream>
#include <string>


//#include "TD_TableauDouble.h"
#include "TD_TableauDouble_Correction.h"

using namespace std;

// Constructeur
TableauDouble::	TableauDouble(unsigned int taille, const string &nom, double def_value):Nom(nom),Taille(taille)
{
    Pt = new double[Taille];
    for(unsigned int i=0; i<Taille; i++)
        Pt[i] = def_value;
}
	

// Constructeur de copie
TableauDouble::TableauDouble( const TableauDouble &tableau)
{
    Nom = tableau.Nom;
	Taille = tableau.Taille;
    Pt = new double[Taille];
    for(unsigned int i=0; i<Taille; i++)
        Pt[i] = tableau.Pt[i];
}


// Destructeur
TableauDouble::~TableauDouble()
{
    delete[] Pt;
}


// Code à commenter suivant l'ordre proposé
//1- Que va faire, en gros, cette méthode?
//1- Pourquoi le const? Est il obligatoire?
//1- Pourquoi la référence?
void TableauDouble::Copie(const TableauDouble &tableau)
{
    if( this != &tableau ) // 5- A quoi sert cette ligne? (dans un main essayer "a.Copie(a);"
        {
        Nom = tableau.Nom;       //2-
        Taille = tableau.Taille; //2-
        delete[] Pt;             //3-
        Pt = new double[Taille]; //3-
        for(unsigned int i=0; i<Taille; i++) //4-
            Pt[i] = tableau.Pt[i];           //4-
        }
}


unsigned int TableauDouble::GetTaille() const
{
    return Taille;
}

string TableauDouble::GetNom() const
{
    return Nom;
}

void TableauDouble::SetNom(string nom)
{
    Nom = nom;
}

// Modification de la taille, les valeurs présentes sont COPIEES dans le nouvel espace...
void TableauDouble::SetTaille( unsigned int taille )
{
	if( Taille != taille )
		{
        // nouvel espace
        double *n_Pt = new double[taille];

        // copie des valeurs, d'abord trouver le nombre
        unsigned int min_taille;
        if( taille > Taille )
            min_taille = Taille;
        else
            min_taille = taille;

        // copie proprement dite
        for(unsigned int i=0; i<min_taille;i++)
            n_Pt[i] = Pt[i];

        // libération ancien espace mememoire
        delete[] Pt;

        // le champs Pt va pointer sur le nouvel espace mémoire
        Pt = n_Pt;

        //mise à jour du champ Taille
        Taille = taille;
		}
}


// Permet d'acceder au ième element du tableau
double  TableauDouble::GetElement( unsigned int i) const
{
	if( (i<Taille) && (i>=0) ) 
        return Pt[i];
    return Pt[0];
}


// Permet d'acceder au ième element du tableau
void  TableauDouble::SetElement( unsigned int i, double v) 
{
    if( (i<Taille) && (i>=0) )
        Pt[i]=v;
}

void TableauDouble::Afficher( void ) const
{
    cout << Nom << " [" << Taille << "] = [ ";
    for( unsigned int i=0; i<Taille-1; i++)
        cout << Pt[i] << ", ";
    cout << Pt[Taille-1] << " ]" << endl;
}


TableauDouble TableauDouble::Plus( const TableauDouble &td) const
{

	unsigned int min_taille;
    if( td.Taille > Taille )
		min_taille = Taille;
	else
        min_taille = td.Taille;

    TableauDouble result(min_taille, this->GetNom() + "+" + td.GetNom());
	for(unsigned int i=0; i<min_taille; i++)
        result.Pt[i] = Pt[i] + td.Pt[i];

	return result;
}