原创 学习C++模板元编程（2）收藏

新一篇: 学习C++模板元编程（3） | 旧一篇: 学习C++模板元编程(1)

  
再看一道简单一些的习题：写一个三个参数的元函数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，即替换后的结果与预期结果全部相符。
 
 

发表于 @ 2006年12月05日 12:04:00|评论(loading...)|编辑

新一篇: 学习C++模板元编程（3） | 旧一篇: 学习C++模板元编程(1)

评论

#puncha 发表于2007-06-21 17:51:34  IP: 207.46.55.*
能够稍微解释一下什么是metafunction forwarding？我找了很久都没找到相关的资料，或者能不能提供一些链接？谢了！！
#alai04 发表于2007-06-21 18:36:23  IP: 125.33.144.*
metafunction forwarding，我把它翻译为元函数前转，要弄清楚它是什么，首先要弄清楚metafunction是什么。
在《C++ Template Metaprogramming》一书中，metafunction被解释为"class templates-as-functions"，象函数一样的类模板。如：
template <typename C, typename X, typename Y>
struct replace_type_d
{
typedef C type;
};
replace_type_d就是一个metafunction，它有三个参数C、X、Y，按boost::MPL的约定，这个"函数"的返回结果用名为type的嵌套typedef来表示。在上例中，"函数"的返回结果就是C。
而metafunction forwarding就是通过利用C++中类的继承，使得派生类自动获得基类中名为type的嵌套typedef，即派生类所表示的metafunction具有与基类所代表的metafunction相同的返回值。例如：
template <typename C, typename X, typename Y>
struct replace_type : replace_type_d<C, X, Y>
{
};
replace_type派生自replace_type_d，它也是一个metafunction，不过它除了派生自replace_type_d以外，没有再定义任何新的东西，所以它具有与replace_type_d相同的嵌套typedef type。
如果用普通函数来类比，就象这样：
int replace_type_d(int c, int x, int y)
{
return c;
}
int replace_type(int c, int x, int y)
{
return replace_type_d(c, x, y);
}
这不就是forwarding吗？
发表评论  


当前用户设置只有注册用户才能发表评论。如果你没有登录，请点击登录
Csdn Blog version 3.1a
Copyright © alai04