Protection contre les dépassements de tableau

Pour se protéger contre les dépassements de tableau on utilise la classe template suivante

template <class T> class A{
 public:       T *cc;      
               long size;  
                    
void init(long ssize);
T&  operator [] (long i) const
    {
      assert ( cc&&(i >= 0) && (i < size) );
      return cc[i];
    }    
 A(long csize = 0)
    {
      size = csize;
      if (size > 0 ) cc = new T[size]; 
      else cc = 0;
    } 
 A(const A& a); 
 A& operator=(const A& a); 
~A() { delete [] cc;size = 0; }  
void destroy() { delete [] cc;size = 0; cc=0; }
int no( T* t) const { return t - cc;}  // return place in array
};

//-----------------------------------------------------
template <class T> void A<T>::init(long ssize)
    {
      assert( !cc && ssize );
      size=ssize;
      cc= new T[size];              
      assert(cc != 0);      
    } 
//-----------------------------------------------------
template <class T>  A<T>::A(const A<T>& a)
    {
       if( a.cc && a.size )
      	{ size = a.size; cc = new T[size];
         for(int i=0; i<size;i++) cc[i] = a.cc[i];
       }
    }
//-----------------------------------------------------
template <class T> A<T>& A<T>::operator=(const A<T>& a)
    {
       assert( cc && a.cc && (a.size==size) );
       for(int i=0; i<size;i++) cc[i] = a.cc[i];
       return *this;
    }

Toute création de tableau doit passer maintenant par les classes A<type>.