Discussion :

[Alfred12]

Bonjour, voici ce que je voudrais faire, je ne sais pas si c'est possible en C++ :
- passer un type comme argument d'une fonction
- utiliser ce type comme paramètre de new

Imaginons une classe base, avec des descendants (fille1, fille2,...) où type_class_base représente le type class base et ses descendants éventuels, et type_class un type de la famille de types type_class_base.

Code :

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

1
2
3
4
5
6
7
8
void func(type_class_base type_class)
{
   base *newvar;
 
   newvar = new type_class(); 
}
...
func(fille2); // Création d'une instance de la class fille2

Merci pour votre aide

[Invité]

tu veux faire un template quoi ...

Code :

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

1
2
3
template<T> func() {
    Base* pBase = new T;
}

[Alfred12]

C'est un peu comme un template, sauf que dans ce cas je veux restreindre le type T à la classe Base et ses descendants (et je voudrais éviter que la classe Base soit template)

[Invité]

C'est un peu comme un template, sauf que dans ce cas je veux restreindre le type T à la classe Base et ses descendants (et je voudrais éviter que la classe Base soit template)

Code :

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

1
2
3
4
5
6
template<T> func() {
    if (T typeof Base) {
        Base* pBase = new T;
    }
}

je ne connais pas la syntaxe exacte du typeof, mais il sert a ce genre de chose... évidemment, si tu passes un type qui hérite de Base, ca marchera aussi

[Alfred12]

J'ai écrit ca, ca passe à la compil mais je ne sais pas comment appeler func()

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
class base
{
public:
   template <typename T> func();
};
 
template <typename T> func()
{
   if (T == typeof(base)) {
      base *obj = new T;
   }
}

[Alfred12]

mais je ne sais pas comment appeler func()

Si, a priori ca devrait être :

Code :

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

fille func();

[Invité]

je me demande s'il ne faut pas mettre la classe en template aussi :

Code :

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

template<T> class base { ... };

et apres, tu l'apelles dans ce style la :

Code :

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

1
2
base<MonType> b;
b.func();

[Jean-Marc.Bourguet]

Bonjour, voici ce que je voudrais faire, je ne sais pas si c'est possible en C++ :
- passer un type comme argument d'une fonction
- utiliser ce type comme paramètre de new

Tu veux du polymorphisme parametrique. La voie normale en C++ c'est d'utiliser les template:

Code :

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

1
2
3
4
5
template<typename T>base* func() {
   return new T();
}
 
base* x = func<fille>();

avec la contrainte que le type soit connu a la compilation. Si ce n'est pas le cas, on peut l'exprimer d'une autre maniere en utilisant les autres polymorphismes disponibles. Il nous faut un objet pour representer le type et que cet objet puisse fournir un pointeur vers un objet construit par defaut:

Code :

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

1
2
3
struct baseBuilder {
   virtual base* build() const {return new base(); } // ou = 0?
};

Il faut de tels objets pour tous les descendants de base, donc

Code :

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

1
2
3
4
 
template <typename T> class baseDescendantBuilder: public baseBuilder {
   base* build() const { return new T(); }
};

func est alors simplement:

Code :

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

1
2
3
4
5
6
7
base* func(baseBuilder const& builder) {
   return builder.build();
}
 
...
base* x = func(baseDescendantBuilder<fille>());
...

C'est plus complique que le code precedant, mais on peut trimbaler des references ou des pointeurs vers les descendant de baseBuilder. On peut faire de celui-ci un singleton si besoin est.

De la on peut aussi partir dans au moins trois directions:
- etendre baseBuilder pour construire aussi d'autres types. Il est maintenant mal nomme, mais on arrive au pattern factory.
- etendre baseBuilder pour contenir d'autres information sur le type. Ca permet de faire une sorte d'introspection et on se retrouve avec une extension du RTTI et quelque chose de semblable aux meta-classes d'autres langages.
- fusionner baseBuilder avec base (on appelle alors generalement build() clone() et on lui fait generer une copie de l'objet sur lequel on l'appelle plutot qu'un objet construit par defaut).