Comment itérer sur un tuple TR1

Question

Étant coincé dans le pays TR1, pour un programme de test, je dois effectuer certaines opérations sur un certain nombre d'objets de types spécifiques. J'ai quelques définitions de types de tuple qui ressemblent à ceci:

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;

Pour chaque type de tuple, un objet doit être créé. J'ai ensuite des modèles de fonction similaires à ceci:

template
void invoke_operation_1(T& obj);

Il est nécessaire d'appeler ces fonctions pour tous les objets d'un objet tuple.

Comment puis-je faire cela en C++03?

Answer 1

Il y avait récemment une fonctionnalité finalisée à Bristol pour C++14 pour aborder ce problème précis. Ce n'est pas trop difficile à gérer.

Pour le cas plus simple, vous pouvez utiliser un modèle récursif. C'est un peu compliqué cependant sans spécialisation partielle des fonctions et autres.

template struct visit_detail {
     template static void call(Tup& t, F f) {
         f(std::tr1::get(t));
         return visit_detail::call(t, f);
     }
};
template struct visit_detail::value> {
    template static void call(Tup& t, F f) {}
}

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

Ici, f peut être préprogrammé ou un objet fonction paramètre ou ce que vous voulez.

Answer 2

Vous pourriez utiliser boost::fusion si vous avez besoin d'appeler la même fonction templatisée pour chaque objet dans le tuple. Par exemple.

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

struct executor
{
    template
    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 3

template
struct visit_detailImpl {
    template
    static void call(tup& t, f f) {
        f(std::tr1::get(t));
        return visit_detailImpl >::call(t, f);
    }
};
template // structure de fin de récursion
struct visit_detailImpl::value> > {
    template
    static void call(tup& t, f f) {}
};
template
void for_each_tup(tup& t, Fn f) {
    return visit_detailImpl >::call(t, f);
}