#ifndef ARRAY_H          // Array.h : tableau homogene
#define ARRAY_H

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

#include <iostream>
using namespace std;

template <class T>
class Array;

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

template <class T>
Array<T> operator+(const Array<T>& a1, const Array<T>& a2);

// export              // ... En theorie, si on ajoute export, ca evite le
template <class T>     // #include "Array.cpp" dans le fichier du prg principal
class Array
{
     friend ostream& operator<< <>(ostream& s, const Array<T>& a);
 /*
  public:    ...           // services
  protected: ...           // utilitaires
  private:   ...           // repreesentation interne
                           // et services internes
 */

  public:

    // Constructeurs/destructeur

     Array(int capacity = 10);               // Constructeur par d´efaut
     Array(const Array<T>& t);               // Constructeur par recopie
     Array<T>& operator=(const Array<T>& t); // Affectation
     Array(const T* CArray, int capacity);   // Constructeur par cousinage
     virtual ~Array(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 Array<T>& a) const;
     bool operator!=(const Array<T>& a) const;

     Array<T>& operator+=(const Array<T>& a);
     friend Array<T> operator+ <>(const Array<T>& a1, const Array<T>& a2);

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

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

    // Modifieurs

     void insert(const T& element);
     T    remove(void);

  private:

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

   // Utilitaires prives de : copie, desallocation, reallocation

     void _copy(const Array<T>& t);
     void _destroy(void);
     void _realloc(int newCapacity);
  
};
#endif // ARRAY_H