TEMPLATE DE VECTEUR AVEC TIRAGE ALEATOIRE (C++)

#include "rand.hpp"
#include <iostream>

using namespace std;

//------------------------------------------------------------------------------
//   Template pour structure de vecteur avec fonctionnalite
//      de tirage aleatoire
//
//------------------------------------------------------------------------------
template <class T>
class AleaVect
{
   protected :
      int _sizeMax; // nombre maximal d'elements
      int _size;    // nombre d'elements actuels
      int _state;   // etat : 0 -> on peut ajouter/enlever des elements
                    //        1 -> on est en cours de tirage dans la vecteur
      T * _vect1;   // vecteur complet (etat 0)
                    // ou contenant les elements non encore tires (etat 1)
      T * _vect2;   // vecteur contenant les elements tires
      int _size1;   // nbre d'elements dans le vecteur 1
      int _size2;   // nbre d'elements dans le vecteur 2
      
   public :
      AleaVect(int inSizeMax); // constructeur
      ~AleaVect();             // destructeur
      int Ajoute(T inType);    // ajout d'un element
      int Enleve(T inType);    // retrait d'un element
      T Alea();                // tirage aleatoire d'un element
};

//------------------------------------------------------------------------------
//   Constructeur
//
//   inSizeMax : nombre maximal d'elements du vecteur
//
//------------------------------------------------------------------------------
template <class T>
AleaVect<T>::AleaVect(int inSizeMax)
{
   _sizeMax = inSizeMax;
   _size = 0;
   _vect1 = new T[inSizeMax];
   _vect2 = new T[inSizeMax];
   _state = 0;
}

//------------------------------------------------------------------------------
//   Destructeur
//
//------------------------------------------------------------------------------
template <class T>
AleaVect<T>::~AleaVect()
{
   delete[] _vect1;
   delete[] _vect2;
}

//------------------------------------------------------------------------------
//   Fonction d'ajout d'un element
//
//   inType : element a ajouter
//   retourne 0 si on peut ajouter et 1 sinon
//
//------------------------------------------------------------------------------
template <class T>
int AleaVect<T>::Ajoute(T inType)
{
   if(_size<_sizeMax && _state==0)
   {
      _vect1[_size++]=inType;
      return 0;
   }
   return 1;
}

//------------------------------------------------------------------------------
//   Fonction de retrait d'un element
//
//   inType : element a retirer
//   retourne 0 si retrait effectue et 1 si l'element n'etait pas present
//
//------------------------------------------------------------------------------
template <class T>
int AleaVect<T>::Enleve(T inType)
{
   bool trouve = false;
   int i = 0;
   
   if(state==0) // si nous ne sommes pas en cours de tirage
   {
      while(!trouve && i<_size) // parcours du vecteur
      {
         if(_vect1[i] == inType)
            trouve = true;
         else
            i++;
      }
   
      if(trouve) // si l'element est present
      {
         for(int j = i ; j<_size-1 ; j++) // decalage du vecteur pour effacer
            _vect1[j] = _vect1[j+1];
         _size--;
         return 0; // element efface
      }
   }
   return 1; // non trouve
}

//------------------------------------------------------------------------------
//   Fonction de tirage d'un element
//     (attention : le vecteur ne doit etre vide)
//
//   retourne l'element tire
//
//------------------------------------------------------------------------------
template <class T>
T AleaVect<T>::Alea()
{
   T res; // variable contenant le resultat;
   
   if(_state == 0) // si on est pas en phase de tirage
   {
      _state = 1; // on se met en etat de tirage aleatoire
      _size1 = _size;
      _size2 = 0;
   }

   int r = random(0, _size1); // tirage d'un index aleatoire

   res = _vect1[r]; // on transfere dans le vecteur 2
   _vect2[_size2] = res;

   for(int j = r ; j<_size1-1 ; j++) // decalage du vecteur
      _vect1[j] = _vect1[j+1];

   _size1--; // reactualisation des tailles des vecteurs
   _size2++;

   if(_size1 == 0) // si tous les elements ont ete tires
   {
      T * temp;
      temp = _vect1;
      _vect1 = _vect2;
      _vect2 = temp;

      _state = 0;
   }

   return res; // element aleatoire
}