Free Store

Lorsqu'il y a beaucoup d'allocation dynamique de petite taille on a grandement intérêt a gérer soi-même l'allocation à l'intérieur d'une grande mémoire allouée une seule fois. Considérons l'exemple suivant

class freestore { public:
//--------------
  long top, storesize, check;
  base** store;
         freestore(const long thestoresize)
  	      {     check=0;storesize = thestoresize;top = -1; 
               store = new base*[storesize];
         }
        ~freestore(){ delete [] store; }
  base*  allocator(const int size);
  void   releaser(base* q);
};

base* freestore::allocator(int size) 
{ 	base* q;
	  if(top >= 0)
		{ cout<<"newS "<<store[top]<<'\t'<<top<<endl; return store[top--];}
	  else 
		{ check++;  q = new base[size];cout<<"new "<<q<<endl; return q;}
}

void freestore::releaser(base* q)
{
	if(top>storesize-2) 
		cout << "max mem store"<<endl;
	store[++top] =  q; cout<<"store "<<q<<'\t'<<top<<endl;
}

freestore mem(10000);
const int N = 10;

class VectnN {public:  base*  val;       
//-------------------------------
         VectnN(const VectnN& r) 
         { 	val = mem.allocator(N); 
         	  for(int i=0;i<N;i++) val[i]=r.val[i];
         } 
         VectnN(base r=0) 		
         { 	val = mem.allocator(N); 
         	  for(int i=0;i<N;i++) val[i]=r;
         } 
         ~VectnN() 				{ mem.releaser(val);}
VectnN& 	operator=	(const VectnN& a);  
base& 		 operator[] 	( int i)   		{ assert((i< 2)&&(i>=0));  return val[i];}
};

Question: On aurait pu declarer val[N] et il n'y aurait pas eu de problème. Pourtant ce n'est pas forcément optimal. Pourquoi?