Discussion :

[Matthieu Brucher]

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 :

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

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 ?

[ternel]

en principe, tu peux faire:

Code :

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

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é

[Matthieu Brucher]

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 :/

[Matthieu Brucher]

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

[ternel]

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 :

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

1
2
3
4
5
6
template<typename T>
class Main : public T
{
public:
    Main(double a, double b) :T(a, b) {}
};

[the Hound]

Bonjour,

Peut-être avec des templates variadiques :

Code :

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

1
2
3
4
5
6
template <typename T>
class Main : public T {
  public:
    template <typename... Args>
      Main(Args&&... args):T(std::forward(args)...) {}
};

[ternel]

je n'y pense pas assez. ca doit marcher

[Matthieu Brucher]

Bonjour,

Peut-être avec des templates variadiques :

Code :

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

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.

[Trademark]

Bonjour,

Peut-être avec des templates variadiques :

Code :

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

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

[the Hound]

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.

[Matthieu Brucher]

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 !

[ternel]

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

[Matthieu Brucher]

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

[r0d]

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.

[Matthieu Brucher]

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