VS2010 C++ variadic template exemple

J'ai un modèle de classe et je n'arrive pas à comprendre comment effectuer une Variadic Template style de l'instanciation.

Ici est le "code" pour l'instant, de ce que je suis à la recherche de:

template<typename _Classname, typename... Args>
class CFunctorStartExT 
{
  friend class CXXFactory;
protected:
  template<typename U>
  CFunctorStartExT(typename U& _functor, Args&... args) :
    m_Functor(_functor),
    m_args(args)
  {
  }
  virtual bool ProcessLoop(CSomeClass* pThread)
  {
    return m_Functor(pThread, m_args);
  }

protected:
  _Classname& m_Functor;
  Args... m_args;
};

Évidemment, cela ne compile pas :). L'idée est de créer une classe qui permet de stocker les valeurs transmises (le cas échéant.. il pourrait juste avoir _Classname/U définie) dans le constructeur de sorte qu'ils peuvent être récupérés plus tard pour passer à m_Functor dans une autre fonction.

D'abord: peut Variadic Template être fait dans VS2010? Je reçois des problèmes à la compilation juste avec le modèle de déclaration error C2143: syntax error : missing ',' before '...' à partir de la ligne de template<typename _Classname, typename... Args>

Seconde, peut ce que je suis en train d'accomplir le faire? Merci!

Les noms commençant par un caractère de soulignement suivi d'une lettre majuscule, comme _Classname, sont réservés et vous ne devriez pas les utiliser dans votre programme.
oh.. réservés pour quoi/qui? J'ai essayé de changer ma convention de nommage.. (changement de m_, g_, etc)
Voir this.

OriginalL'auteur BabelFish | 2011-01-21

  1. 26

    Visual C++ 2010 ne prend pas en charge les variadic templates.

    lol.. la poisse.. 🙁 de toute façon à accomplir ce que je suis en train de faire via variadic des macros? Je sais que std::make_shared a un variadic de style mais je me suis perdu dans tous les définit.
    Est-ce à dire que quelqu'un à Microsoft fait beaucoup de copier-coller pour obtenir une limited tuple de la classe?
    non.. ils ont cette macros définir le "mécanisme" qui définit et annule la définition pour créer les classes nécessaires.. à partir de ce que je peux dire. vous le voyez dans les fichiers xxshared et xfwrap et xfwrap1 etc
    Par souci d'exhaustivité, avec des larmes dans mes yeux: connect.microsoft.com/VisualStudio/feedback/details/463677/...
    McNellis: Apparemment, ils ne seront pas dans VS11.

    OriginalL'auteur James McNellis

  2. 3

    Je crois que la suite va faire ce que vous voulez. D'abord vous avez besoin d'un utilitaire:

    //make_tuple_indices

template <size_t...> struct tuple_indices {};

template <size_t _Sp, class _IntTuple, size_t _Ep>
struct make_indices_imp;

template <size_t _Sp, size_t ..._Indices, size_t _Ep>
struct make_indices_imp<_Sp, tuple_indices<_Indices...>, _Ep>
{
    typedef typename make_indices_imp<_Sp+1, tuple_indices<_Indices..., _Sp>, _Ep>::type type;
};

template <size_t _Ep, size_t ..._Indices>
struct make_indices_imp<_Ep, tuple_indices<_Indices...>, _Ep>
{
    typedef tuple_indices<_Indices...> type;
};

template <size_t _Ep, size_t _Sp = 0>
struct make_tuple_indices
{
    static_assert(_Sp <= _Ep, "make_tuple_indices input error");
    typedef typename make_indices_imp<_Sp, tuple_indices<>, _Ep>::type type;
};

    Ensuite, vous pouvez l'utiliser pour vous aider à développer un tuple de la tenue de vos arguments:

    template<typename _Classname, typename... Args>
class CFunctorStartExT 
{
  friend class CXXFactory;
protected:
  template<typename U>
  CFunctorStartExT(U& _functor, Args&... args) :
    m_Functor(_functor),
    m_args(args...)
  {
  }

  virtual bool ProcessLoop(CSomeClass* pThread)
  {
    return ProcessLoop(pThread,
                       typename make_tuple_indices<sizeof...(Args)>::type());
  }

protected:
  _Classname& m_Functor;
  std::tuple<Args...> m_args;

private:
    template <std::size_t ...Indx>
    bool ProcessLoop(CSomeClass* pThread, tuple_indices<Indx...>)
    {
        return m_Functor(pThread, std::get<Indx>(m_args)...);
    }
};

    Autant que VS2010 variadic template utilisé: je n'ai aucune idée.

    Bienvenue à Débordement de Pile!
    ce serait formidable si VS2010 pourrait soutenir "typename..."
    Merci cela a résolu un scénario assez similaire j'ai besoin d'aide avec. Serait-il d'accord pour inclure votre tuple_indices/make_tuple_indices code MIT-comme sous licence de la bibliothèque? La Licence peut être consultée ici: angelcode.com/angelscript/sdk/docs/manual/doc_license.html
    Le code ci-dessus est en fait déjà sous licence MIT, si je n'ai pas pris la peine avec la licence de cet extrait, et c'est une technique courante. Voici d'où il vient: libcxx.llvm.org dans l'en-tête __tuple : llvm.org/svn/llvm-project/libcxx/trunk/include/__tuple . Il serait génial si vous pouviez comprendre les droits d'auteur dans l' __tuple et la référence à l'LICENSE.TXT.
    Ok merci encore. Je vais attendre avec impatience les prochains articles sur ces "techniques" pour l'utilisation efficace de variadic templates. J'ai seulement commencé à travailler avec eux et bien que mon code est beaucoup plus clair avec les variadic templates (plutôt que de préprocesseur hacks), j'ai été assez déçu de voir qu'il n'existe pas de niveau de langue, facilité pour obtenir l'indice élargi de paramètres ou arguments. Pas de doute, il y aura une avalanche de nouveaux livres maintenant que C++11 est en voie de ratification, cependant.

    OriginalL'auteur Howard Hinnant

  3. -2

    Variadic templates sont un patch sur une bidouille sur un hack -- vous n'allez pas profiter de cette. La façon de le faire (sur le dessus de ma tête) est d'utiliser un modèle de spécialisation en collaboration avec l'héritage. Quelque chose le long de ces lignes:

    template<typename Classname, typename... Args>
class CFunctorStartExT;

template<typename Classname, typename Arg0, typename... Args>
class CFunctorStartExT : private CFunctorStartExT<Classname, Args...> {
protected:
  Arg0 m_arg;
};

template<typename Classname>
class CFunctorStartExT {
protected:
  Classname &m_Functor;
};

    Je n'ai jamais fait cela avant, et ne l'ai pas testé, mais c'est l'idée générale. Vous pourriez avoir un coup d'oeil à un std::tuple mise en œuvre pour quelque chose qui fonctionne réellement.

    OriginalL'auteur Thomas