VS2010 C ++ esempio modello variadic
-
16-10-2019 - |
Domanda
Ho un modello di classe e io non riesco a capire come eseguire uno stile di un'istanza 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 sarà compilato :). L'idea è quella di creare una classe che può memorizzare i valori passati (se presente .. si potrebbe semplicemente avere _className / U definita) sul costruttore in modo che possano essere recuperati successivamente passare ad m_Functor in un'altra funzione.
Per prima cosa: Can variadic Template anche essere fatto in VS2010? Io sono sempre problemi di compilazione solo con la dichiarazione di error C2143: syntax error : missing ',' before '...'
modello dal template<typename _Classname, typename... Args>
riga
In secondo luogo, può quello che sto cercando di realizzare da fare? Grazie!
Soluzione
Visual C ++ 2010 non supporta i modelli variadic.
Altri suggerimenti
Credo che la seguente vi fare 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)...);
}
};
Per quanto riguarda il supporto VS2010 modello variadic:. Non ho idea di
??variadic sono una patch su un ripiego su un hack - non si sta andando a godere di questo. Il modo per farlo (la parte superiore della mia testa) è quello di utilizzare template specializzazione insieme con l'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 ho mai fatto prima, e non hanno provato, ma questa è l'idea generale. Si potrebbe avere uno sguardo a un'implementazione std::tuple
per qualcosa che funziona davvero.