学习C++模板元编程（2）

 

再看一道简单一些的习题：写一个三个参数的元函数 replace_type<c, x, y>，其中第一个参数c为任意的组合类型，该元函数将c中出现的所有x类型以y类型替换掉。例如：

typedef replace_type< void*, void, int >::type t1; // int*   typedef replace_type<int const*[10], int const, long>::type t2; // long* [10]   typedef replace_type<char& (*)(char&), char&, long&>::type t3; // long& (*)(long&)

为简单起见，可以假设 c如果是函数类型的话，其参数数量不超过2个。

我的想法是这样的， replace_type<c, x, y>模板以c = x为条件进行偏特化，主模板就符合c != x的条件，把它转为另一个元函数replace_type_d<c, x, y>；再将replace_type_d<>按c的类型（分为引用、指针、CV限定、数组、函数等）进行偏特化，递归调用replace_type<>。

replace_type<>部分的程序如下：

#include <iostream> #include "boost/type_traits/is_same.hpp"   template <typename C, typename X, typename Y> struct replace_type_d;   template <typename C, typename X, typename Y> struct replace_type : replace_type_d<C, X, Y> { };   template <typename X, typename Y> struct replace_type<X, X, Y> {     typedef Y type; };

这一段代码先给出 replace_type_d<>的声明，然后定义replace_type<>的主模板，使用元函数前转（metafunction forwarding）的方法，直接调用replace_type_d<>。最后是c = x的replace_type<>的偏特化模板，由于c = x，所以结果是直接返回y类型。

replace_type_d<>部分的程序如下：

template <typename C, typename X, typename Y> struct replace_type_d {     typedef C type; };   template <typename C, typename X, typename Y> struct replace_type_d<C&, X, Y> {     typedef typename replace_type<C, X, Y>::type& type; };   template <typename C, typename X, typename Y> struct replace_type_d<C*, X, Y> {     typedef typename replace_type<C, X, Y>::type* type; };   template <typename C, typename X, typename Y> struct replace_type_d<C const, X, Y> {     typedef typename replace_type<C, X, Y>::type const type; };   template <typename C, typename X, typename Y> struct replace_type_d<C volatile, X, Y> {     typedef typename replace_type<C, X, Y>::type volatile type; };   template <typename C, typename X, typename Y, std::size_t n> struct replace_type_d<C[n], X, Y> {     typedef typename replace_type<C, X, Y>::type type[n]; };   template <typename R, typename X, typename Y> struct replace_type_d<R(*)(), X, Y> {     typedef typename replace_type<R, X, Y>::type RetType;     typedef RetType (*type)(); };   template <typename R, typename A, typename X, typename Y> struct replace_type_d<R(*)(A), X, Y> {     typedef typename replace_type<R, X, Y>::type RetType;     typedef typename replace_type<A, X, Y>::type ArgType;     typedef RetType (*type)(ArgType); };   template <typename R, typename A1, typename A2, typename X, typename Y> struct replace_type_d<R(*)(A1, A2), X, Y> {     typedef typename replace_type<R, X, Y>::type RetType;     typedef typename replace_type<A1, X, Y>::type Arg1Type;     typedef typename replace_type<A2, X, Y>::type Arg2Type;     typedef RetType (*type)(Arg1Type, Arg2Type); };

这一段代码首先是 replace_type_d<>的主模板，直接返回c类型。接下来是replace_type_d<>的8个偏特化版本，分别对应c的各种类型：引用、指针、const限定、volatile限定、数组、无参函数、一元函数、二元函数。由于题目假定如果c为函数类型，其参数数量不超过2个，因此最多只涉及到二元函数。每个偏特化版本都非常相似，针对不同的情况对c进行分解，然后分别对分解后的类型递归调用replace_type<>来获得替换结果，再对替换结果进行组合，得到最终的结果。如：对于引用类型，分解出被引用类型，对其调用replace_type<>获得中间替换结果，再加上引用，就得到最终替换结果。又比如：对于一元函数类型，分解出函数返回类型及参数类型，分别对它们调用replace_type<>获得两个中间替换结果，再用这两个中间结果组合成一元函数，就得到最终替换结果。

最后是测试用的 main()及运行结果，如下：

int main() {     typedef replace_type<void*, void, int>::type t1;     std::cout << boost::is_same<t1, int*>::value << std::endl;     typedef replace_type<int const*[10], int const, long>::type t2;         std::cout << boost::is_same<t2, long*[10]>::value << std::endl;     typedef replace_type<char&(*)(char&), char&, long&>::type t3;     std::cout << boost::is_same<t3, long&(*)(long&)>::value << std::endl;     return 0; }   Output: 1 1 1

输出的三个 1代表了三个true，即替换后的结果与预期结果全部相符。