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