Écrit variadic template constructeur

J'ai demandé récemment à cette question, mais maintenant, je tiens à le développer. J'ai écrit la classe suivante:

template <class T>
class X{
public:
    vector<T> v;
    template <class T>
    X(T n) {
        v.push_back(n);
    }
    template <class T, class... T2>
    X(T n, T2... rest) {
        v.push_back(n);
        X(rest...);
    }
};

Lors de la création d'un objet à l'aide

X<int> obj(1, 2, 3);  //obj.v containts only 1

Vecteur ne contient que la première valeur, mais pas d'autres. J'ai vérifié et vu que le constructeur est appelé 3 fois, donc je suis probablement la création d'une temp objets et de remplissage de leurs vecteurs, avec le reste des arguments. Comment puis-je résoudre ce problème?

Pourquoi ne pas simplement template <typename ...Args> X(Args ...args) : v({args...}) {}?
Génial! Merci.
Votre classe ne devrait vraiment se std::initializer_list<T> argument au lieu d'avoir un variadic template constructeur. C'est idiomatiques.
Je suis nouveau en C++11, donc encore de l'apprentissage.

OriginalL'auteur Tracer | 2015-03-04

c++c++11 variadic-templates

28

Tout d'abord, votre code ne compile pas pour moi.
```
main.cpp:7:15: error: declaration of ‘class T’
     template <class T>
               ^
main.cpp:3:11: error:  shadows template parm ‘class T’
 template <class T>
           ^
```
J'ai changé de l'extérieur à U.
```
template <class U>
class X{
public:
    vector<U> v;
    template <class T>
    X(T n) {
        v.push_back(n);
    }
    template <class T, class... T2>
    X(T n, T2... rest) {
        v.push_back(n);
        X(rest...);
    }
};
```
Vous avez raison que cela provoque le problème que vous avez donné à la question de détails...
```
X<int> obj(1, 2, 3);  //obj.v containts only 1
```
C'est parce que la déclaration X(rest...) à la fin de votre constructeur n'est pas récursivement appeler le constructeur de poursuivre l'initialisation de l'objet même; il crée un nouveau X objet qu'on jette ensuite. Une fois qu'un constructeur corps commence à s'exécuter, il n'est plus possible d'invoquer un autre constructeur, sur le même objet. La délégation doit se produire dans le ctor-initialiseur. Ainsi, par exemple, vous pourriez faire ceci:
```
template <class T, class... T2>
X(T n, T2... rest): X(rest...) {
    v.insert(v.begin(), n);
}
```
Qui suce bien que, en raison de l'insertion, au début d'un vecteur n'est pas efficace.

Mieux de prendre un std::initializer_list<T> argument. C'est ce que std::vector lui-même n'.
```
X(std::initializer_list<U> il): v(il) {}
//...
X<int> obj {1, 2, 3};
```
Étrange. Je n'ai pas d'erreurs de compilation (VS 2013). Mais oui, je comprends où est le problème. Merci.

OriginalL'auteur
5

Tout à fait d'accord avec Brian réponse, mais même si la bonne approche est d'une autre (c'est à dire utiliser initializer_list) s'il vous plaît être conscient (pour le plaisir de le faire correctement dans d'autres circonstances) que variadic template récursivité dans ce cas pourrait être beaucoup plus simple de juste en notant qu'un vide pack est un modèle valide paramètre pack, de sorte que les variadic template constructeur sera appelé une dernière fois avec le bloc-batterie vide, ce qui conduira à essayer de faire appel à un défaut ctor, qui peut être affichée par défaut et de mettre fin à la récursivité.

OIE, ce qui suit de travail et serait beaucoup plus propre de l'OMI:
```
template <class T>
struct X
{
    std::vector<T> v;
    X() = default; //Terminating recursion

    template <class U, class... Ts>
    X(U n, Ts... rest)  : X(rest...) { .. the recursive work ..}
};
```
Encore une fois, je ne dis pas que les modèles et la récursivité sont la bonne chose ici, je signale simplement que seraient-ils nécessaires, il y aurait un moyen plus simple de les utiliser.

OriginalL'auteur
2

Il n'est pas nécessaire pour la récursivité, en premier lieu -

vous pouvez utiliser le "tableau temporaire" d'un langage et d'écriture
```
template <class... E>
X(E&&... e) {
    int temp[] = {(v.push_back(e), 0)...};
}
```
La bonne (et plus complexe) version de cette approche ressemble à ceci:
```
template <class... E>
X(E&&... e) {
    (void)std::initializer_list<int>{(v.push_back(std::forward<E>(e)), void(), 0)...};
}
```
Version Live

Noter que la prochaine version de C++ seront sans doute les Plier Les Expressions

(v.push_back(e), ...);

OriginalL'auteur

template <class T, class... Rest>
  X(T n, Rest... rest) {
   add(rest...);
 }

//Just another member function
template<class T>
  void add(T n) {
    v.push_back(n);
 }
  template<class T, class ... Rest>
   void add(T n, Rest... rest) {
     v.push_back(n);
     add(rest...);

 }

Bienvenue sur StackOverflow. Si cela peut répondre à la question, veuillez fournir une brève explication de ce que votre code ne fait et comment il résout le problème initial.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.