Constructeur de modèle C++

Question

Je souhaite avoir une classe sans modèle avec un constructeur de modèle sans arguments.

D'après ce que j'ai compris, il est impossible de l'avoir (parce qu'il y aurait conflit avec le constructeur par défaut - J'ai raison ? ), et la solution de contournement est la suivante :

class A{
   template <typename U> A(U* dummy) {
   // Do something
   }
};

Peut-être existe-t-il une meilleure alternative pour cela (ou une meilleure solution de contournement) ?

Gracias.

Answer 1

Il n'y a aucun moyen de spécifier explicitement les arguments du modèle lors de l'appel d'un modèle de constructeur, ils doivent donc être déduits par déduction d'argument. Ceci est dû au fait que si vous dites :

Foo<int> f = Foo<int>();

El <int> est la liste d'arguments du modèle pour le type Foo mais pas pour son constructeur. La liste d'arguments du modèle de constructeur n'a nulle part où aller.

Même avec votre solution de contournement, vous devez toujours passer un argument afin d'appeler ce modèle de constructeur. Ce que vous essayez de faire n'est pas du tout clair.

Answer 2

Vous pouvez créer une fonction d'usine modélisée :

class Foo
{
public:
    template <class T> static Foo* create() // could also return by value, or a smart pointer
    {
        return new Foo(...);
    }
...        
};

Answer 3

D'après ce que j'ai compris, il est impossible de l'avoir (parce que cela entrerait en conflit avec le constructeur par défaut - ai-je raison ?).

Vous avez tort. Il n'y a pas de conflit d'aucune sorte. Vous ne pouvez juste pas l'appeler jamais.

Answer 4

Quelques points :

• Si vous déclarez tout constructeur (y compris un modèle un modèle), le compilateur s'abstiendra de déclarer un constructeur par défaut.
• A moins que vous ne déclariez un constructeur de copie (pour la classe X un qui prend X o X& o X const & ) le compilateur va générer le constructeur de copie par défaut.
• Si vous fournissez un modèle de constructeur pour la classe X qui prend T const & o T o T& alors le le compilateur générera néanmoins un non modélisé par défaut non tempéré, même si vous pensez qu'il ne devrait pas le faire parce que lorsque T = X, la déclaration correspond à celle du constructeur de copie.
• Dans ce dernier cas, vous pouvez fournir un constructeur de copie non modélisé en plus de celui qui est modélisé. Ils ne seront pas en conflit. Lorsque X est passé, le non-modèle sera appelé. Sinon, le modèle

HTH

Answer 5

Essayez de faire quelque chose comme

template<class T, int i> class A{

    A(){
          A(this)
    }

    A( A<int, 1>* a){
          //do something
    }
    A( A<float, 1>* a){
         //do something
    }
.
.
.
};