Type de class et arguments pour fonctions et new

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:

---

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

tu veux faire un template quoi ...

Code:

---

1 2 3

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

---

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)

Citation:

---

Envoyé par 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)

---

Code:

---

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

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

Code:

---

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; } }

---

Citation:

---

mais je ne sais pas comment appeler func()

---

Si, a priori ca devrait être :

Code:

---

fille func();

---

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

Code:

---

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

---

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

Code:

---

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

---

D'après le Mega Cours C++, il est possible d'avoir une fonction template dans une classe qui ne l'est pas.

En fait j'ai un problème à la compilation (référence externe non-trouvée sur ma fonction template). J'ai aussi essayé de faire une fonction template à l'extérieur de ma classe et j'ai le même problème.

Code:

---

1 2 3 4 5 6

template <typename T> void func() { base *obj = new T; } ... func<fille>(); // Référence externe non-trouvée

---

Citation:

---

Envoyé par 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

---

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

Code:

---

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:

---

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:

---

1 2 3 4

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

---

func est alors simplement:

Code:

---

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).

Citation:

---

Envoyé par Alfred12

Code:

---

1 2 3 4 5 6

template <typename T> void func() { base *obj = new T; } ... func<fille>(); // Référence externe non-trouvée

---

---

Je ne vois rien de bizarre. Donne un code complet, minimal et ne presentant que l'erreur qui te preoccupe ici.

Citation:

---

Je ne vois rien de bizarre.

---

Effectivement, j'avais mis le code du template dans le fichier .cpp. Dans le fichier d'entête ca marche beaucoup mieux.

Merci pour cette réponse détaillée. En fait je ne sais pas encore si j'aurais besoin de la seconde solution que je vais regarder de près mais la première, suggérée aussi par toxcct, fonctionne maintenant et correspond à mes besoins immédiats.

Citation:

---

if (T == typeof(base)) {
base *obj = new T;
}

---

En fait ca ne compile pas du tout et c'est inutile car si T n'est pas de type base le code ne compile pas.

Citation:

---

Envoyé par Alfred12

Effectivement, j'avais mis le code du template dans le fichier .cpp. Dans le fichier d'entête ca marche beaucoup mieux.

---

J'aurais du y penser. C'est une :faq:

On peut utiliser le SFINAE pour détecter si la classe reçue dérive bien publiquement de Base. Je suppose qu'avec les concepts du C++09, on pourra faire des trucs encore plus propres.

Il y a des trucs pour faire ça dans Loki (qui sont détaillé dans une section d'un chapitre de Modern C++ Design), et probablement dans boost aussi.

Citation:

---

Envoyé par Luc Hermitte

On peut utiliser le SFINAE pour détecter si la classe reçue dérive bien publiquement de Base.

---

On veut ici que l'instanciation échoue dans ce cas, ce qu'elle fait toute seule... qu'apporterait SFINAE?

Des macros qui vont permettre des choses un chouilla plus génériques, qui permettront à leur tour de renvoyer un T* plutôt qu'un Base*, tout en apportant la contrainte, et sans jouer avec des casts explicites.

Si renvoyer un Base* suffit. Et bien .. ca suffit effectivement amplement :)

Y'a les type traits de TR1 pour ça (qui proviennent de boost).
is_base_of permet en particulier de savoir si un type est une base ou est dérivé d'un autre type.