Generazione di tuple da tuple

Question

Supponiamo di avere una tupla e di voler generare una nuova tupla applicando una metafunzione su ciascun tipo della prima. Qual'è la metafunzione C++ più efficiente da eseguire in questo compito? È anche possibile utilizzare il modello variadico C++ 0x per fornire un'implementazione migliore?

Answer 1

Come 'bout questo:

template<typename Metafun, typename Tuple> 
struct mod; 

// using a meta-function class 
template<typename Metafun, template<typename...> class Tuple, typename ...Types> 
struct mod<Metafun, Tuple<Types...>> { 
    typedef Tuple<typename Metafun::template apply<Types>::type...> 
    type; 
}; 

Poi

typedef std::tuple<int, bool> tuple_foo; 

struct add_pointer { 
    template<typename T> 
    struct apply { typedef T *type; }; 
}; 

typedef mod<add_pointer, tuple_foo>::type tuple_ptrfoo; 

che sta utilizzando una classe metafunction avvolgendo il apply in un non-modello. Ciò consente di passarlo a modelli C++ 03 (che non possono accettare modelli con parametri arbitrari semplicemente facendo template<typename...> class X). Si può, ovviamente, accettare un metafunction puro (non una classe) troppo

template<template<typename...> class Metafun, typename Tuple> 
struct mod; 

// using a meta-function 
template<template<typename...> class Metafun, template<typename...> class Tuple, 
     typename ...Types> 
struct mod<Metafun, Tuple<Types...>> { 
    typedef Tuple<typename Metafun<Types>::type...> 
    type; 
}; 

e utilizzare il std::add_pointer modello

typedef mod<std::add_pointer, tuple_foo>::type tuple_ptrfoo; 

Oppure si può avvolgerlo in una classe in modo che sia compatibile con il primo versione

// transforming a meta function into a meta function class 
template<template<typename...> class Metafun> 
struct ToClass { 
    template<typename ... T> 
    struct apply { typedef Metafun<T...> type; }; 
}; 

typedef mod<ToClass<std::add_pointer>, tuple_foo>::type tuple_ptrfoo; 

Spero che sia d'aiuto.