VS2010 Esempio di modello variadico C++

Question

Ho un modello di classe e non riesco a capire come eseguire un'istanza di stile Variadic Template.

Ecco il "codice" finora di quello che sto cercando:

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; 
}; 

Ovviamente questo non compilerà :). L'idea è di creare una classe in grado di memorizzare i valori passati (se ce ne sono ... potrebbe avere solo _Classname/U definiti) sul costruttore in modo che possano essere recuperati in seguito per passare a m_Functor in un'altra funzione.

Primo: è possibile eseguire il modello Variadic in VS2010? Ricevo problemi di compilazione solo con la dichiarazione modello error C2143: syntax error : missing ',' before '...' dalla riga template<typename _Classname, typename... Args>

In secondo luogo, è possibile eseguire ciò che sto cercando di realizzare? Grazie!

Answer 1

Visual C++ 2010 non supporta i modelli variadic.

Answer 2

I modelli di Variadic sono una patch su un kludge su un hack: non ti piacerà questo. Il modo per farlo (in cima alla mia testa) è utilizzare la specializzazione del modello insieme all'ereditarietà. Qualcosa in questo senso:

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; 
}; 

non l'ho mai fatto prima, e non hanno provato, ma questa è l'idea generale. Potresti dare un'occhiata all'implementazione di std::tuple per qualcosa che funziona davvero.

Answer 3

Credo che quanto segue farà quello che vuoi. In primo luogo è necessario un programma di utilità:

// 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; 
}; 

quindi è possibile utilizzare questo per aiutare a espandere una tupla tenendo le argomentazioni:

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

quanto riguarda il sostegno modello variadic VS2010: Non ne ho idea.