TableauDyn.h

Go to the documentation of this file.

#ifndef TABLEAUDYN_H
#define TABLEAUDYN_H

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <cstdlib>

using namespace std;

template<class T> class TableauDyn{
public:
//Constructeurs
        TableauDyn();

        TableauDyn(int nb);


        TableauDyn(const TableauDyn<T> &l);
        //Destructeurs
        ~TableauDyn();
        //Ajouts

        TableauDyn<T> & Cons(T val, int pos);

        TableauDyn<T> & ConsTete(T val);

        TableauDyn<T> & ConsQueue(T val);

        //Modification
        void Modifier(int pos, T elt);

        void SetTaille(unsigned int nb);
        //Destructions

        TableauDyn<T> & Detruit(unsigned int i);

        TableauDyn<T> & DetruitVirtuel(unsigned int pos);
        //Consultations

        unsigned int Card() const;

        T Tete() const;

        T Valeur(int i) const;

        T operator[](int i) const;

        void Afficher() const;
        //Affectations
        const TableauDyn<T> &operator=(const TableauDyn<T> &l);
protected:
        T *mTab;

        int mCard;
};

//Constructeurs

template<class T> TableauDyn<T>::TableauDyn(){
        mCard=0;
        mTab=NULL;
}

template<class T> TableauDyn<T>::TableauDyn(int nb){
        mCard=nb;
        mTab=new T [nb];
}

template<class T> TableauDyn<T>::TableauDyn(const TableauDyn<T> &l){
        delete [] mTab;
        mCard=l.Card();
        mTab=new T [mCard];
        for(unsigned int i=0; i<l.Card(); i++){
                mTab[i]=l[i];
        }
}
//Destructeurs

template<class T> TableauDyn<T>::~TableauDyn(){
        delete [] mTab;
        mCard=0; 
}
//Ajouts

template<class T> TableauDyn<T> &  TableauDyn<T>::Cons(T val, int pos){
        //Allocation du tableau temporaire
        T *tab=new T[mCard+1];
        //Recopie jusqu pos
        for(int i=0; i<pos; i++){
                tab[i]=mTab[i];
        }
        //Construction en pos de la valeur
        tab[pos]=val;
        //Recopie du reste
        for(int i=pos; i<mCard; i++){
                tab[i+1]=mTab[i];
        }
        //Desctruction de l'ancien tableau
        delete[] mTab;
        //Nouvelle allocation
        mTab=new T[mCard+1];
        //Recopie
        for(int i=0; i<mCard+1; i++){
                mTab[i]=tab[i];
        }
        mCard++;
        //Destruction du tableau temporaire
        delete[] tab;
        return (*this);
}

template<class T> TableauDyn<T> &  TableauDyn<T>::ConsTete(T val){
        Cons(val,0);
        return (*this);
}

template<class T> TableauDyn<T> &  TableauDyn<T>::ConsQueue(T val){
        Cons(val,mCard);
        return (*this);
}
//Modification
template<class T> void TableauDyn<T>::Modifier(int pos, T elt){
        mTab[pos]=elt;
}

template<class T> void TableauDyn<T>::SetTaille(unsigned int nb){
        delete[] mTab;
        mCard=nb;
        mTab=new T [nb];
}

//Destructions
template<class T> TableauDyn<T> & TableauDyn<T>::DetruitVirtuel(unsigned int pos){
        mCard--;
        return (*this);
}

template<class T> TableauDyn<T> & TableauDyn<T>::Detruit(unsigned int pos){
        T *tab=new T[mCard-1];
        //on recopie tout sauf pos
        int k=0;
        for(int i=0; i<mCard; i++){
                if(i!=pos){
                        tab[k]=mTab[i];
                        k++;
                }
        }
        //on supprime mTab
        delete[] mTab;
        mTab=new T[mCard-1];
        for(int i=0; i<mCard-1; i++){
                mTab[i]=tab[i];
        }
        //on supprime tab
        delete[] tab;
        if(mCard>0) mCard--;
        return (*this);
}
//Consultations
template<class T> unsigned int TableauDyn<T>::Card() const{
        return mCard;
}
template<class T> T TableauDyn<T>::Tete() const{
        return mTab[0];
}
template<class T> T TableauDyn<T>::Valeur(int i) const{
        return mTab[i];
}
template<class T> T TableauDyn<T>::operator[](int i) const{
        return mTab[i];
}
template<class T> void TableauDyn<T>::Afficher() const{
        for(int i=0; i<mCard; i++){
                cout<<mTab[i]<<" ";
        }
}
//Affectations
template<class T> const TableauDyn<T> &TableauDyn<T>::operator=(const TableauDyn<T> &l){
        delete [] mTab;
        mCard=l.Card();
        mTab=new T [mCard];
        for(unsigned int i=0; i<l.Card(); i++){
                mTab[i]=l[i];
        }
        return (*this);
}

#endif

---