编写一个元函数,该如何处理

编写一个元函数

C/C++ code

template<typename C, typename A, typename B>
struct type_replace;

接受一个复合类型C作为第一个参数,并将其中的类型A替换为类型B

C/C++ code

typedef type_replace< void*, void, int > :: result_type t1; // int*

typedef type_replace< int const* [10], int const, long > :: result_type t2; // long* [10]

typedef type_replace< char& (*)(char&, const char*), char&, long > :: result_type t3;// long (*)(long, const char*)

c++ template metaprogramming 中的一道例题, 想了好久, 郁闷

------解决方案--------------------
代码量还是不小的，如果不用boost库里已经现成的部分组件的话。
要之，就是T的所有可能复合类型也就T、T *、T []、 T &及一些对应的const版本，得穷举出来，特化处理。
------解决方案--------------------
这个问题有意思，貌似没有简单易行的解法，临时写了一个比较基本的，涵盖不了所有情况，不过LZ列出的几种情况都能够处理了。

C/C++ code

 
 #include  <cstddef> 

 template  <typename,typename> struct is_same { enum { value = false }; }; 
 template  <typename T> struct is_same  <T, T> { enum { value = true  }; }; 

 template  <bool, typename, typename> struct select; 
 template  <typename T, typename U> struct select  <true ,T,U> { typedef T type; }; 
 template  <typename T, typename U> struct select  <false,T,U> { typedef U type; }; 

 // General 
 template  <typename T, typename X, typename Y> 
 struct replace { typedef typename select <is_same <T,X>::value,Y,T>::type type; }; 

 // Simple composite 
 template  <typename T, typename Y> struct replace  <T&,T&,Y> { typedef Y type; }; 
 template  <typename T, typename Y> struct replace  <T*,T*,Y> { typedef Y type; }; 
 template  <typename T, typename Y> struct replace  <T[],T[],Y> { typedef Y type; }; 
 template  <typename T, typename Y, size_t S> 
 struct replace  <T[S],T[S],Y> { typedef Y type; }; 

 // Compound composite 
 template  <typename T, typename X, typename Y> 
 struct replace  <T&,X,Y> 
 { typedef typename replace <T,X,Y>::type& type; }; 

 template  <typename T, typename X, typename Y> 
 struct replace  <T*,X,Y> 
 { typedef typename replace <T,X,Y>::type* type; }; 

 template  <typename T, typename X, typename Y> 
 struct replace  <T[],X,Y> 
 { typedef typename replace <T,X,Y>::type type [] ; }; 

 template  <typename T, typename X, typename Y, size_t size> 
 struct replace  <T[size],X,Y> 
 { typedef typename replace <T,X,Y>::type type [size]; }; 

 // Functions 
 template  <typename R, typename X, typename Y> 
 struct replace  <R(),X,Y> 
 { typedef typename replace <R,X,Y>::type (type) (); }; 

 template  <typename R, typename A1, typename X, typename Y> 
 struct replace  <R(A1),X,Y> 
 { typedef typename replace <R,X,Y>::type (type) (typename replace <A1,X,Y>::type); }; 

 template  <typename R, typename A1, typename A2, typename X, typename Y> 
 struct replace  <R(A1,A2),X,Y> 
 { 
  typedef typename replace <R,X,Y>::type (type) 
 (typename replace <A1,X,Y>::type, typename replace <A2,X,Y>::type); 
 }; 

 // Pointers to member functions 
 template  <typename C, typename R, typename X, typename Y> 
 struct replace  <R (C::*) (),X,Y> 
 { typedef typename replace <R,X,Y>::type (replace <C,X,Y>::type :: * type) (); };

编写一个元函数,该如何处理

相关推荐