#ifndef ABSTRACTARRAY_H          // AbstractArray.h : tableau homogene
#define ABSTRACTARRAY_H

#define MAX 10

// Pour les fonctions friend template :
// http://gnu.cict.fr/software/gcc/faq.html#friend

#include <iostream>
using namespace std;

template <class T>
class AbstractArray;

template <class T>
ostream& operator<<(ostream& s, const AbstractArray<T>& a);

// export           // ... En theorie, si on ajoute export, ca evite le
template <class T>  // #include "AbstractArray.cpp" du fichier du prg principal
class AbstractArray
{
     friend ostream& operator<< <>(ostream& s, const AbstractArray<T>& a);

  public:

    // Constructeurs/destructeur

     AbstractArray(int capacity = MAX);         // Constructeur par d´efaut
     AbstractArray(const AbstractArray<T>& t);  // Constructeur par recopie
     AbstractArray<T>& operator=(const AbstractArray<T>& t); // Affectation
     AbstractArray(const T* CArray, int capacity);// Constructeur par cousinage
     virtual ~AbstractArray(void);                           // Destructeur

    // Transtypage

     operator T*(void);

    // Inspecteurs

     int  size(void) const;
     int  capacity(void) const;
     bool empty(void) const;
     bool full(void) const;
     int  has(const T& element) const;        // retourne l’index ou -1

    // Operateurs

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

     bool operator==(const AbstractArray<T>& a) const;
     bool operator!=(const AbstractArray<T>& a) const;

     AbstractArray<T>& operator+=(const AbstractArray<T>& a);
//   friend AbstractArray<T> operator+(const AbstractArray<T>& a1, // => Classe
//                                     const AbstractArray<T>& a2);// concrete!

     AbstractArray<T>& operator<<(const T& element);
     AbstractArray<T>& operator>>(T& element);

     T operator()(const T& t, T (*f)(const T&,const T&)) const;

    // Modifieurs

     virtual void insert(const T& element) = 0;         // virtuelle pure
     virtual T    remove(void);                         // virtuelle

  protected:

     int _size;     // nombre d’elements dans le tableau
     int _capacity; // capacite du tableau
     T*  _t;        // tableau C dynamique

  private:

   // Utilitaires prives de : copie, desallocation

     virtual void _copy(const AbstractArray<T>& t); // virtuelle
     virtual void _destroy(void);                   // virtuelle
  
};
#endif // ABSTRACTARRAY_H