C de méta programmation pour créer une nouvelle typelist avec remove_const appliqué à chaque élément

Question

Salut Quelqu'un pourrait-il me donner un exemple de programme « Créer un modèle ApplyRemoveConst que construit une nouvelle typelist avec remove_const appliqué à chaque élément »

Par exemple :

typedef TYPELIST_3(A, const B, B) TL; 
typedef ApplyRemoveConst<TL>::Result TL2; 
// TL2 is the same as TYPELIST_3(A, B, B) 


//Typelist Definition: 

template<class T, class U> 
struct Typelist 
{ 
    typedef T Head; 
    typedef U Tail; 
    // Lets us a print a typelist 
    inline static ostream &print(ostream &os) { 
     return printInternal(os, "["); 
    } 
    inline static ostream &printInternal(ostream &os, string delimiter) { 
     os << delimiter << typeid(Head).name(); 
     return Tail::printInternal(os, ", "); 
    } 
private: 
    Typelist(); // Cannot create! 
}; 

#define TYPELIST_1(T1) Typelist<T1, NullType> 
#define TYPELIST_2(T1, T2) Typelist<T1, TYPELIST_1(T2)> 
#define TYPELIST_3(T1, T2, T3) Typelist<T1, TYPELIST_2(T2, T3)> 

// Null type definition 

class NullType{ 
public: 
    // NullType ends a typelist (just like NULL ends a C string) 
    inline static ostream &printInternal(ostream &os, string delimiter) { 
     return os << "]"; 
    } 
}; 

Answer 1

Je pense que ce que vous voulez est quelque chose comme ceci:

template <typename, template <typename> class> 
struct transform; 

template <template <typename> class Func> 
struct transform<NullType, Func> 
{ 
    typedef NullType type; // nothing to do 
}; 

template <typename T, typename U, template <typename> class Func> 
struct transform<Typelist<T, U>, Func> 
{ 
    typedef typename Func<T>::type Head; // apply to head 
    typedef typename transform<U, Func>::type Tail; // tail is transformed tail 

    typedef Typelist<Head, Tail> type; // put together 
}; 

cela vaut quelque chose re cursivement. Il fait une nouvelle liste, en appliquant à la tête, puis en prenant tout le reste comme la queue, appliquée. Cela à son tour applique la tête, et ainsi de suite, jusqu'à ce qu'un NullType est atteint dans lequel nous venons d'obtenir NullType.

Ensuite, vous avez juste besoin d'une méta-foncteur:

template <typename T> 
struct remove_const 
{ 
    typedef T type; 
}; 

template <typename T> 
struct remove_const<const T> 
{ 
    typedef T type; 
}; 

les mettre ensemble:

typedef TYPELIST_3(A, const B, B) TL; 
typedef transform<TL, remove_const>::type TL2; 
// TL2 is the same as TYPELIST_3(A, B, B) 

_{Il convient de noter que je ne l'ai pas essayé de tout cela.}