Jak iterować nad krotką TR1

Question

Utknął w ziemi TR1, dla programu testowego muszę wykonać pewne operacje na wielu obiektach określonego typu. Mam kilka definicji typu krotek, które wyglądają tak:

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; 

Z każdego typu krotki należy utworzyć obiekt. Następnie mam szablony funkcjonalne podobne do tego:

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

Te muszą być wywoływane dla wszystkich obiektów w obiekcie krotki.

Jak to zrobić w C++ 03?

Answer 1

Możesz użyć boost::fusion, jeśli chcesz wywołać tę samą szablonową funkcję dla każdego obiektu w krotce. Na przykład.

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

W Bristol została właśnie sfinalizowana funkcja C++ 14, która rozwiązała ten problem. Nie jest to trudne.

Dla prostszego przypadku można użyć szablonu rekursywnego. To smaganie bałaganu, ale bez specjalizacji częściowej funkcji i takie.

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

Tutaj f może być oznaczony na sztywno lub obiekt funkcji parametru lub cokolwiek chcesz.

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