template typedef

Bonjour tout le monde,

Il me souvient qu'ici meme on m'avait enjoint =E0 diff=E9rencier les
types d'objets diff=E9rents, meme lorsque leur impl=E9mentation devait
etre la meme. Par exemple :
On devrait diff=E9rencier un *TriangularGrid* d'un *TriangularBezierNet*
d'un *TriangularBezierPatch* juste parce que ce ne sont pas les memes
objets, et meme si, en d=E9finitive, on les impl=E9mente de la meme
fa=E7on... En l'occurrence, j'ai un
template<class T> class TriangularGrid {
private :
int d; // degree
std::vector<T> grid; // stores the grid nodes
int map(int i,int j, int k) const throw (BezierErr) { // computes
index of node (i,j,k) in the grid vector
return ((d-i)*(d+1-i)/2 + k);
};

public :
//! trivial constructor
TriangularGrid(int d=3D0):d(d){ };
//! copy constructor
TriangularGrid(TriangularGrid const &gr){
d =3D gr.d;
grid=3Dgr.grid;
};
//! destructor
virtual ~TriangularGrid(){};

//! insert from vector
void load(TriangularGrid const &std::vector<T> vect){
if (vect.size()<d) throw (DegreeErr("Not enough values in this
vector"));
grid=3Dvect;
d=3D((int) (sqrt(1+8*vect.size()))) -1;
};
//! returns the degree of the grid
int degree() const {return d;}
//! returns a const ref to the node, for reading or call via const
functions
T const&
get(int i,int j,int k) const {
return grid[map(i,j,k)];}
//! returns a ref to the node, for modification
T&
get(int i,int j,int k){
return grid[map(i,j,k)];}
//! sets a node to a value
void set(int i,int j,int k, T const &p){grid[map(i,j,k)]=3Dp;};
};

et comme je suis flemmard et inquiet de toute redondance de code
j'aimerai ecrire un truc du genre :
template<class T> typedef TriangularGrid<T> TriangularBezierNet<T>
qui bien entendu ne fonctionne pas...

Mais peut etre finalement devrais-je plutot consid=E9rer la solution
consistant =E0 faire une super classe de mon TriangularGrid et =E0 la
d=E9river en BezierNet et BezierPatch... ?