Templates et constructeurs de classe héritées

Hey,
J'ai un souci pour une construction en C++11 qui m'embête.

J'ai une classe template qui hérite de son paramètre template, et elle n'a pas de constructeur par défaut :

Code:

---

1 2 3 4 5 6

template<typename T> class Main : public T { public: // méthodes };

---

Ca fonctionne très bien pour la majorité de mes classes mère, mais j'ai maintenant besoind 'avoir une classe fille qui a un constructeur qui prend des arguments. Le souci, c'est que je pensais que le constructeur de Main suivrait le prototype de celui de ma classe mère, mais apparemment dans le monde des templates, ce n'est pas le cas.
J'ai tenté des using, mais comme le nom du constructeur est différent selon la classe fille, ça ne passe pas !

Des idées ?

en principe, tu peux faire:

Code:

---

1 2 3 4 5 6

template<typename T> class Main : public T { public: Main() :T("un argument") {} };

---

Théoriquement, il existe les "inherited constructors", mais je ne les ai pas encore utilisé

En principe, mais en fait non. Parce que T peut avoir différentes signatures, selon son type. Par défait, ça sera T(), donc tout passe, mais dans le cas qui me préoccupe, c'est T(double, double).

J'aimerait bien utiliser les constructeurs dérivés, le souci, c'estq ue faire un using T::T va ramener la méthode "T" de ma classe parente, pas son constructeur :/

Bon... J'ai constaté que mon Visual Studio n'avait pas les inherited constructors...

Tu peux avoir recours à la spécialisation, si la taille de la classe est modeste, et qu'il y a peu de cas à traiter.

Tu peux avoir recours à une classe de base, éventuellement template de T, pour ne pas tout redéfinir dans la spécialisation.

Si tu sais que tu utiliseras ta template uniquement avec certaines classes, le problème est bien réduit.

Si tu sais que c'est "(double, double)", ma proposition est valable:

Code:

---

1 2 3 4 5 6

template<typename T> class Main : public T { public: Main(double a, double b) :T(a, b) {} };

---

Bonjour,

Peut-être avec des templates variadiques :

Code:

---

1 2 3 4 5 6

template <typename T> class Main : public T { public: template <typename... Args> Main(Args&&... args):T(std::forward(args)...) {} };

---

je n'y pense pas assez. ca doit marcher

Citation:

---

Envoyé par the Hound

Bonjour,

Peut-être avec des templates variadiques :

Code:

---

1 2 3 4 5 6

template <typename T> class Main : public T { public: template <typename... Args> Main(Args&&... args):T(std::forward(args)...) {} };

---

---

Ca semble intéressant, je vais voir si mes compilateurs supportent ça (certains sont très vieux :()
Merci !

leternel > sans doute, mais la classe est tout de même un peu complexe, et elle était là pour abstraire toute la partie setup d'un traitement. Le traitement est identique, mais tout de même assez complexe.

Citation:

---

Envoyé par the Hound

Bonjour,

Peut-être avec des templates variadiques :

Code:

---

1 2 3 4 5 6

template <typename T> class Main : public T { public: template <typename... Args> Main(Args&&... args):T(std::forward(args)...) {} };

---

---

Quitte à faire ça autant faire de la composition plutôt que de l'héritage en passant le T en paramètre du constructeur (en plus ça passera sur de vieux compilateurs).

Tout dépend de ce qui est recherché ici, si on veut que Main fournisse la même "interface" que la classe qu'elle reçoit en paramètre template, c'est une solution possible. Bien sûr dans des cas concrets on va rarement recourir à ce genre de design.

Citation:

---

Envoyé par Trademark

Quitte à faire ça autant faire de la composition plutôt que de l'héritage en passant le T en paramètre du constructeur (en plus ça passera sur de vieux compilateurs).

---

Je me suis posé la question, mais pour le moment, je reste avec de l'héritage, mais c'est clair qu'il est possible que ça change. Le souci est que la composition va cacher l'objet qui a sa propre interface qui doit être accessible. Bref, je verrai pour la release officielle de la 1.0 !

en composant, tu peux proposer, par exemple, les operateurs * et ->, pour inférer vers la classe composée. Comme le fait un smart pointer ou un optional

:/ oui et non. La classe composée doit utiliser des outils de la classe de base (typiquement des fréquences d'échantillonnage) pour calculer ses coefficients. Et au-dessus de ça, il y a la classe qui fait le calcul en nécessitant l'interface de la classe de base (car polymorphisme dynamique) et la partie "amovible" de calcul des coeffs. C'est pas instantané de séparer les deux.
En fin de compte, j'ai dû modifier le constructeur pour qu'il prenne en compte un autre paramètre et je suis passé par une méthode protégée pour setter les paramètres, le tout dans des méthodes builder (statiques).

Bonjour,

l'inverse ne serait-il pas possible? Je veux dire, faire hériter ta classe Main de ta nouvelle classe, plutôt que l'inverse? J'ai vu ça récemment dans la lib OpenSceneGraph, ici.

Juste pour la culture générale, ce pattern s'appelle le CRTP.

C'est déjà ce que j'utilise en réalité :) (la classe IIRFilter dans https://github.com/mbrucher/AudioTK)