Discussion :

[Shibron]

Bonjour a tous,

Alors j'ai un petit problème avec les template. En gros j'ai une premiere classe templatée par une entier et dans une deuxieme classe je souhaite stocker comme donnée membre un vector de vector sur ma première classe mais avec des paramètres template différents. Mais vous comprendrez surement mieux avec le code...

La signature de la première classe :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
template<int dimension, int k, typename T>
class iCellule

Et la deuxième :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template<int dimensionComplex, int dimensionPts, typename T>
class Complexe {
public:
private:
    // stocker un tableau de pointeurs sur les ensembles contenant les icellules...
    std::vector<std::vector<iCellule>* > mesICellules;

Et je voudrais en fait ici avoir des vector sur icellule pour tout les k allant de 0 à dimensionComplex. Mon problème est qu'évidemment, le compilo me jette parce que je n'ai pas donnée les bon template pour la classe iCellule. Mais si je lui met un k, il me dit qu'il ne le connait pas... Donc je coince là :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template<int dimensionComplex, int dimensionPts, typename T>
class Complexe {
public:
private:
    // stocker un tableau de pointeurs sur les ensembles contenant les icellules...
    std::vector<std::vector<iCellule<dimensionPts, k, T> >* > mesICellules;

J'espère que c'est clair... Merci d'avance.

[Arzar]

Bonjour,

Et bien il y a deux solutions :

Soit en fixant la valeur de k :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template<int dimensionComplex, int dimensionPts, typename T>
class Complexe {
public:
private:
    // stocker un tableau de pointeurs sur les ensembles contenant les icellules...
    std::vector<std::vector<iCellule<dimensionPts, 5, T> >* > mesICellules;

Soit en rajoutant ce paramètre template k à la classe Complexe.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
template<int dimensionComplex, int dimensionPts, typename T, int k>
class Complexe {
public:
private:
    // stocker un tableau de pointeurs sur les ensembles contenant les icellules...
    std::vector<std::vector<iCellule<dimensionPts, k, T> >* > mesICellules;

Pas de miracle en tout cas avec les templates, tout doit être connu à la compilation !

[Flob90]

Tu peux faire quelque chose comme ca :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
template<size_t i>
class T {};
 
template<size_t j>
class U : U<j-1>
{
  std::vector<T<j>*> v;
  public:
    void foo(size_t k)
    {
      if (j == k) v.push_back(new T<j>());
      else U<j-1>::foo(k);
    }
};
 
template<>
class U<0>
{
  std::vector<T<0>*> v;
  public:
    void foo(size_t)
    { v.push_back(new T<0>()); }
};

A adpater selon ce que tu veux faire, et tu dois pouvoir améliorer un peu (beaucoup même), en utiliser les outils de méta-prog de boost (il faut chercher).

[Shibron]

Je suis pas sur de bien comprendre ce que tu me propose Flob90, c'est une sorte de template récursif que tu fais la ? L'idée est plutôt classe en tout cas...

Mais si je comprends bien, tu as plusieurs instances de la classe U qui stockent chacune un vecteur de pointeurs vers la classe T templatée par la même valeur que le template de U ? C'est pas mal seulement moi je voudrais une seule instance de U qui me stocke selon la valeur de son template, une série de vecteurs vers les T templatés chacun par 0, 1, 2... jusqu'à la valeur du template de U.

En gros pour appliquer ca en ayant qu'une seule instance, il faudrait que je dérive de toute les valeurs de template qui vont de 0 à mon j c'est ca !?

[Flob90]

C'est bien basé sur la récursivité. Voila comment j'ai vue les choses :
- Si le paramètre (template de U) est 0 alors il contient un seul vector de T<0>*
- Sinon il contient plusieurs vecteur de T<i>* avec i allant de 0 à n avec n le paramètre (template de U), donc il contient des vecteur de T<i>* i allant de 0 à n-1 et un vecteur de T<n>*, on peut donc voir ca comme contenir un vecteur de T<n>* et un U<n-1>

Pour une relation has-a (notre cas) il y a deux solutions :
- une donnée membre, c'est ce que j'ai fait pour le vecteur de T<n>*
- un héritage privé (ou protégé), c'est ce que j'ai fait pour le U<n-1> (une donnée membre aussi aussi marché, ie un U<j-1> u et pas l'héritage).

Donc au final U<n> contient bien n+1 vecteur de T<i>* i allant de 0 à n, après le problème c'est comment accéder à chaque vecteur, ce que j'ai essayer d'illustrer avec ma fonction membre foo (on peut améliorer largement cette partie selon l'utilisation réel que tu en fais, si tu connais l'indice à la compilation par exemple).

[Shibron]

Franchement c'est impressionnant ce que tu viens de me fournir !! Et même si je risque de produire un code anti optimal parce que moi j'initialise justement les plus bas niveaux en premier ca marche du tonnerre et c'est quand même super classe comme code !!

Merci beaucoup à toi Flob90 !