Come eseguire iterazione su una tetra TR1

Question

Essendo bloccato in terra TR1, per un programma di test è necessario eseguire determinate operazioni su un numero di oggetti di tipi specifici. Ho un paio di definizioni del tipo tupla che assomigliano a questo:

typedef std::tr1::tuple< bool 
         , signed char 
         , signed short 
         , signed int 
         , signed long long 
         , unsigned char 
         , unsigned short 
         , unsigned int 
         , unsigned long long > integral_types; 

Da ogni tipo tupla un oggetto deve essere creato. Allora ho modelli di funzione simile a questo:

template<typename T> 
void invoke_operation_1(T& obj); 

Questi devono essere chiamati per tutti gli oggetti in un oggetto di tupla.

Come si fa in C++ 03?

Answer 1

È possibile utilizzare boost::fusion se è necessario chiamare la stessa funzione di modello per ogni oggetto nella tupla. Per esempio.

template<typename T> 
void invoke_operation_1(T& obj) 
{ 
    std::cout << obj << std::endl; 
} 

struct executor 
{ 
    template<typename T> 
    void operator()(T& t) const 
    { 
     invoke_operation_1(t); 
    } 
}; 

typedef boost::tuple< bool 
         , signed char 
         , signed short 
         , signed int 
         , signed long long 
         , unsigned char 
         , unsigned short 
         , unsigned int 
         , unsigned long long > integral_types; 
int main() 
{ 
    integral_types t(true, 0, 1, 2, 3, 4, 5, 6, 7); 
    boost::fusion::for_each(t, executor()); 
    return 0; 
} 

Answer 2

C'era una funzionalità appena conclusa a Bristol per C++ 14 per risolvere questo problema. Non è troppo difficile da affrontare.

Per il caso più semplice, è possibile utilizzare un modello ricorsivo. È un po 'di confusione senza specializzazione di funzione parziale e così via.

template<typename Tup, std::size_t N> struct visit_detail { 
    template<typename F> static void call(Tup& t, F f) { 
     f(std::tr1::get<N>(t)); 
     return visit_detail<Tup, N+1>::call(t, f); 
    } 
}; 
template<typename Tup> struct visit_detail<Tup, std::tr1::tuple_size<Tup>::value> { 
    template<typename F> static void call(Tup& t, F f) {} 
} 

template<typename Tup, typename F> void visit(Tup& t, F f) { 
    return visit_detail<Tup, 0>::call(t, f); 
} 

Qui f può essere hardcoded o un oggetto funzione parametro o qualsiasi altra cosa si desideri.

Answer 3

template<typename tup, typename N> 
struct visit_detailImpl { 
    template<typename f> 
    static void call(tup& t, f f) { 
     f(std::tr1::get<N::value>(t)); 
     return visit_detailImpl<tup, std::integral_constant<std::size_t, N::value + 1> >::call(t, f); 
    } 
}; 
template<typename tup> // end recursion struct 
struct visit_detailImpl<tup, std::integral_constant<std::size_t, std::tr1::tuple_size<tup>::value> > { 
    template<typename f> 
    static void call(tup& t, f f) {} 
}; 
template<typename tup, typename Fn> 
void for_each_tup(tup& t, Fn f) { 
    return visit_detailImpl<tup, std::integral_constant<std::size_t, 0> >::call(t, f); 
}