Discussion :

[Flo.]

Bonjour, je voudrais travailler avec une classe templatée ClassB<T> qui se construirait à partir de d'une autre classe templatée ClassA<T>. Du style :

Code :

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

1
2
ClassA<T> maClassA;
ClassB<T> maClassB(maClassA);

Par contre, si au moment d'instancier un objet de ClassB<T> je ne connais pas T, comment faire ?

ClassA<T> pourrait créer un ClassB<T> mais on se trouverait dans des includes croisée.

J'ai également vu dans certains posts que Boost possèderait des outils pour ce faire. Mais je me dis que la stl doit posséder ses propres solutions non ?

Merci

Flo.

[aoyou]

Pourrais-tu expliquer un peu plus ton problème ? Est-ce que tu cherches à faire quelque chose comme ceci.

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
 
template <typename T>
class A {
public:
  A (const T & i) : _i (i) {}
private:
  T _i;
};
 
template <typename T>
class B {
public:
  B (const A<T> & a) : _a (a) {}
private:
  A<T> _a;
};
 
int main () {
  A <int> a (1);
  B <int> b (a);
  return 0;
}

Par contre, si au moment d'instancier un objet de ClassB<T> je ne connais pas T, comment faire ?

C'est là que je ne suis pas... Ton type T doit forcément être connu à la compilation. Si tu ne peux pas encore déterminer le type T à l'instanciation d'un objet de la ClassB, il faut que la fonction ou la classe qui fait cette instanciation soit aussi un template...

[loufoque]

Bonjour, je voudrais travailler avec une classe templatée ClassB<T> qui se construirait à partir de d'une autre classe templatée ClassA<T>.

Code :

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

1
2
3
4
5
template<typename T>
struct ClassA
{
    typedef ClassB<T> make_ClassB;
};

[Flo.]

En fait c'est dans un contexte de mécanisme de polymorphisme. Et c'est également en managé .NET ...

Une classe A dont vont hériter toutes les objets de classe B templatées :

Code :

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

1
2
3
4
5
6
ref ClassA
{
public: ClassA()
{
}
};

Une classe B templatée qui hérite de classe A :

Code :

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

1
2
3
4
5
6
template <class T> ref ClassB : ClassA
{
public: ClassB()
{
}
};

Une classe C templatée qui se construit à partir d'une classe B.

Code :

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

1
2
3
4
5
6
template <class T> ref ClassC
{
public: ClassC(ClassB<T> ^ classB)
{
}
};

Code :

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

1
2
3
4
5
6
7
8
9
10
11
int main()
{
// on crée 2 objets de classe B de type T différents
ClassB<int> ^ classB1 = gcnew ClassB<int>;
ClassB<double> ^ classB2 = gcnew ClassB<double>;
 
// je les mets dans une liste de type de la classe A
List<ClassA ^> ^ desClassB = gcnew List<ClassA ^>;
desClassB->Add(classB1);
desClassB->Add(classB2);
}

Ensuite je veut créér un un objet de ClassC à partir de chaque objet de ClassB contenu dans la liste

Code :

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

1
2
3
4
5
6
7
8
9
 
for(int index = 0; index < (int)desClassB.size(); index++)
{
if(dynamic_cast<ClassB<int>>(desClassB[index]))
     ClassC<int> ^ classC = gcnew ClassC<int>(dynamic_cast<ClassB<int>>(desClassB[index]));
 
else if(dynamic_cast<ClassB<double>>(desClassB[index]))
ClassC<double> ^ classC = gcnew ClassC<double> (dynamic_cast<ClassB<double>>(desClassB[index])); 
}

N'y a-t-il pas moyen de se passer des comparaisons précédente et d'utiliser une méthode plus ... générique, style (c'est n'importe quoi bien sur) :

Code :

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

1
2
3
4
5
6
 
for(int index = 0; index < (int)desClassB.size(); index++)
{
ClassC<typeid(desClassB[index])> ^ classC = 
       gcnew ClassC<typeid(desClassB[index])>(dynamic_cast<ClassB<typeid(desClassB[index])>>(desClassB[index]);
}

J'espère que c'est plus clair. Et désolé quant au c++.NET mais je voulais avoir en c++ non managé car la même problématique se poserait (en tous cas pour moi) en c++ standart.

Flo.

[screetch]

si ClassC est une classe fille de ClassParentC, alors tu peux demander a ClassA de creer le ClassC correspondant, en le manipulant ensuite sous forme de ClassParantC

en gros :

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
ClassA
{
  virtual ClassParentC* makeC() = 0;
};
 
ClassB<T>
{
  virtual ClassC<T>* makeC() { return new ClassC<T>; }
};
 
...
for(int index = 0; index < (int)desClassB.size(); index++)
{
     ClassParentC^ classC = desClassB[index]->makeC();
}

'est un mix C++ non managé/managé mais tu peux t'y retrouver.

Plus précisément : tu stockes dans un vecteur des objets generiques, tu ne pourras plus jamais manipuler les types précis sans recourir au dynamic_cast. a partir du moment ou tu as perdu le type exact, tu vas devoir travailler avec un type restreint. au mieux, tu peux restreindre les autres types pour s'accomoder (c'est a dire, creer une classe ClassParentC qui va regrouper les differentes fonctionnalités communes a tous les ClassC).

Si cela ne convient pas, tu vas devoir soit demander dynamiquement le type, soit _ne pas perdre le type precis_ en stockant tes valeurs dans differents tableaux au lieu d'un seul.

[Flo.]

Je te remercie mais la solution ne me convainc pas.

Je préfère tester mes types un par un.

Merci quand même.

Flo.