关于类型擦除,在网上搜出来的中文资料比较少,而且一提到类型擦除,检索结果里就跑出很多 Java 和 C# 相关的文章来(它们实现“泛型”的方式)。所以,这一篇我打算写得稍微详细一点。 注意,这是一篇读书笔记(《C++ template metaprogramming》第9.7小节和《C++ テンプレートテクニック》第七章),里面的例子都来自原书。
在 C++ 中,编译器在编译期进行的静态类型检查是比较严格的,但有时候我们却希望能“避过”这样的类型检查,以实现更灵活的功能,同时又尽量地保持类型安全。听起来很矛盾,而且貌似很难办到。但其实 C++ 的库里已经有很多这样的应用了。比如,著名的 boost::function 和 boost::any 。当我们定义一个 function<void(int)> fun 对象,则 fun 即可以存储函数指针,又可以存储函数对象,注意,这两者是不同“类型”的,而且函数对象可以是无限种类型的,但这些不同类型的“东西”都可以存在同一类型的对象 fun 中,对 fun 来说,它关心的只是存储的“对象”是不是“可以按某种形式(如void(int))来调用”,而不关心这个“对象”是什么样的类型。有了 function 这样的库,在使用回调和保存可调用“对象”的时候,我们就可以写出更简单且更好用的代码来。再举一个例子,boost::any 库。any 可以存储任何类型的“对象”,比如 int ,或是你自己定义的类 MyCla 的对象。这样我们就可以使一个容器(比如 vector<boost::any> )来存储不同类型的对象了。
这些库所表现出来的行为,就是这篇文章中要提到的类型擦除,类型擦除可以达到下面两个目的:
- 用类型 S 的接口代表一系列类型 T 的的共性。
- 如果 s 是 S 类型的变量,那么,任何 T 类型的的对象都可以赋值给s。
好了,下面我们具体地看看类型擦除是怎么回事,在这个过程中,我们先以 any 这个类为依托来解释(因为它比较“简单”,要解释的额外的东西比较少)。
any 这个类需要完成的主要任务是:1. 存储任何类型的变量 2. 可以相互拷贝 3. 可以查询所存变量的类型信息 4. 可以转化回原来的类型(any_cast<>)
对于其中,只要说明1和2 ,就能把类型擦除的做法展示出来了,所以,我们这里只实现一个简单的,有1、2、3功能的any类(3是为了验证)。
首先,写个最简单的“架子”出来:
class my_any { ?? content_obj; public: template <typename T> my_any(T const& a_right); };
这里,由于 my_any 的拷贝构造函数使用的是模板函数,因此,我们可以任何类型的对象来初始化,并把该对象的复本保存在 content_obj 这个数据成员中。那么,问题是,content_obj 用什么类型好呢?
首先我们会想到,给 class 加个模板参数 T ,然后……,不用然后了,这样的话,使用者需要写这样的代码:
my_any<someType> x = y;
不同的 y 会创造出不同类型的 x 对象,完全不符合我们要将不同类型对象赋给同一类型对象的初衷。接着,我们会想到用 void *(C 式的泛型手法啊……),但这样的话,我们就会完全地丢失原对象的信息,使得后面一些操作(拷贝、还原等)变得很困难,那么,再配合着加入一些变量用于保存原对象信息?你是说用类似“反射”的能力?好吧,我只好说,我以为 C++ 不存在原生的反射能力,以我浅薄的认识,我只知道像 MFC 式的侵入式手法……,嗯,此路不通。
这个困境的原因在于,在C++ 的类中,除了类模板参数之外,无法在不同的成员(函数、数据成员)之间共享类型信息。在这个例子中,content_obj 无法得知构造函数中的 T 是什么类型。所以类型无法确定。
为了妥善保存原对象复本,我们定义两个辅助类,先上代码(来自 boost::any 的原码):
class placeholder { public: // structors virtual ~placeholder() { } public: // queries virtual const std::type_info & type() const = 0; virtual placeholder * clone() const = 0; }; template<typename ValueType> class holder : public placeholder { public: // structors holder(const ValueType & value): held(value) { } public: // queries virtual const std::type_info & type() const { return typeid(ValueType); } virtual placeholder * clone() const { return new holder(held); } public: // representation ValueType held; };
首先,定义了一个基类 placeholder ,它是一个非模板的抽象类,这个抽象类的两个接口是用来抽取对保存在 my_any 中的各种类型对象的共性的,也就是,我们需要对被保存在 my_any 中的数据进行拷贝和类型查询。
然后用一个模板类 holder 类继承 placeholder 类,这个(类)派生类实现了基类的虚函数,并保存了相关的数据。注意,派生类的数据成员的类型是 ValueType,也就是完整的原对象类型,由于它是个模板类,各个类成员之间可以共享类模板参数的信息,所以,可以方便地用原数据类型来进行各种操作。
有了这两个辅助类,我们就可以这样写 my_any 了:
class My_any { placeholder * content_obj; public: template <typename T> My_any(T const& a_right):content_obj(new T(a_right)) {} template <typename T> My_any & operator = (T const& a_right) { delete content_obj; content_obj = new T(a_right); return *this; } My_any(My_any const& a_right) : content_obj(a_right.content_obj ? a_right.content_obj->clone() : 0) { } std::type_info& type() const { return content_obj ? content_obj->type() : typeid(void); } };
现在 my_any 类的 content_obj 的类型定义成 placeholder * ,在构造函数(和赋值运算符)中,我们使用 holder 类来生成真实的“备份”,由于 holder 是模板类,它可以根据赋值的对象相应地保存要我们需要的信息。这样,我们就完成了在赋值的时候的“类型擦除”啦。在 my_any 的 public 接口( type() )中,利用 placeholder 的虚函数,我们就可以进行子类提供的那些操作,而子类,已经完整地保存着我们需要的原对象的信息。
接着我们看下 boost::function 中的 Type Erasure。相比起 boost::any 来,function 库要复杂得多,因为这里只是想讲 boost::function 中的“类型擦除”,而不是 boost::function 源码剖析,所以,我们仍然本着简化简化再简化的目的,只挑着讨论一些“必要”的成分。
我们假设 function 不接受参数。为了更好的说明,我先帖代码,再一步一步解释,注意,下面是一片白花花的代码,几没有注释,千万别开骂,请跳过这段代码,后面会有分段的解释:
#include <iostream> #include <boost/type_traits/is_pointer.hpp> #include <boost/mpl/if.hpp> using namespace std; union any_callable { void (*fun_prt) (); // 函数指针 void * fun_obj; // 函数对象 }; template<typename Func, typename R> struct fun_prt_manager { static R invoke(any_callable a_fp) { return reinterpret_cast<Func>(a_fp.fun_prt)(); } static void destroy(any_callable a_fp) {} }; template<typename Func, typename R> struct fun_obj_manager { static R invoke(any_callable a_fo) { return (*reinterpret_cast<Func*>(a_fo.fun_obj))(); } static void destroy(any_callable a_fo) { delete reinterpret_cast<Func*>(a_fo.fun_obj); } }; struct funtion_ptr_tag {}; struct funtion_obj_tag {}; template <typename Func> struct get_function_tag { typedef typename boost::mpl::if_< boost::is_pointer<Func>, // 在VC10中标准库已经有它啦 funtion_ptr_tag, funtion_obj_tag >::type FunType; }; template <typename Signature> class My_function; template <typename R> class My_function<R()> { R (*invoke)(any_callable); void (*destory)(any_callable); any_callable fun; public: ~My_function() { clear(); } template <typename Func> My_function& operator = (Func a_fun) { typedef typename get_function_tag<Func>::FunType fun_tag; assign(a_fun, fun_tag()); return *this; } R operator () () const { return invoke(fun); } template <typename T> void assign (T a_funPtr, funtion_ptr_tag) { clear(); invoke = &fun_prt_manager<T, R>::invoke; destory = &fun_prt_manager<T, R>::destroy; fun.fun_prt = reinterpret_cast<void(*)()>(a_funPtr); } template <typename T> void assign (T a_funObj, funtion_obj_tag) { clear(); invoke = &fun_obj_manager<T, R>::invoke; destory = &fun_obj_manager<T, R>::destroy; fun.fun_obj = reinterpret_cast<void*>(new T(a_funObj)); } private: void clear() { if (!destory) { destory(fun); destory = 0; } } }; int TestFun() { return 0; } class TestFunObj { public: int operator() () const { return 1; } }; int main(int argc, char* argv[]) { My_function<int ()> fun; fun = &TestFun; cout<<fun()<<endl; fun = TestFunObj(); cout<<fun()<<endl; }
首先需要考虑的是,数据成员放什么?因为我们需要存储函数指针,也需要存储函数对象,所以,这里定义一个联合体:
union any_callable { void (*fun_prt) (); // 函数指针 void * fun_obj; // 函数对象 };
用来存放相应的“调用子”。另外两个数据成员(函数指针)是为了使用上的方便,用于存储分别针对函数指针和函数对象的相应的“操作方法”。对于函数指针和函数对象这两者,转型(cast)的动作都是不一样的,所以,我们定义了两个辅助类 fun_prt_manager 和 fun_obj_manager,它们分别定义了针对函数指针和函数对象进行类型转换,然后再引发相应的“调用”和“销毁”的动作。
接下来是类的两个 assign 函数,它们针对函数针指和函数对象,分别用不同的方法来初始化类的数据成员,你看:
invoke = &fun_prt_manager<T, R>::invoke; destory = &fun_prt_manager<T, R>::destroy; fun.fun_prt = reinterpret_cast<void(*)()>(a_funPtr);
当 My_function 的对象是用函数指针赋值时,invoke 被 fun_prt_manager 的 static 来初始化,这样,在“调用”时就把数据成员转成函数指针。同理,可以知道函数对象时相应的做法(这里就不啰嗦了)。
但如何确定在进行赋值时,哪一个 assign 被调用呢?我想,熟悉 STL 的你,看到 funtion_ptr_tag 和 funtion_obj_tag 时就笑了,是的,这里的 get_function_tag 用了 type_traise 的技法,并且,配合了 boost::mpl 提供的静态 if_ 简化了代码。这样,我们就完成了赋值运算符的编写:
template <typename Func> My_function& operator = (Func a_fun) { typedef typename get_function_tag<Func>::FunType fun_tag; assign(a_fun, fun_tag()); return *this; }
有了这个函数,针对函数指针和函数对象,My_function 的数据成员都可以正确的初始化了。
如我们所见,在 My_function 中,使用了很多技巧和辅助类,以使得 My_funtion 可以获取在内部保存下函数指针或是函数对象,并在需要的时候,调用它们。函数指针或是函数对象,一旦赋值给 My_funtion,在外部看来,便失去了原来的“类型”信息,而只剩下一个共性——可以调用(callable)
这两个例子已经向你大概展示了 C++ 的“类型擦除”,最后,再补充一下我的理解:C++中所说的“类型擦除”不是有“标准实现”的一种“技术”(像 CRTP 或是 Trais 技术那样有明显的实现“规律”),而更像是从使用者角度而言的一种“行为模式”。比如对于一个 boost::function 对象来说,你可以用函数指针和函数对象来对它赋值,从使用者的角度看起来,就好像在赋值的过程中,funtion pointer 和 functor 自身的类型信息被抹去了一样,它们都被“剥离成”成了boost::function 对象的类型,只保留了“可以调用”这么一个共性,而 boost::any ,则只保留各种类型的“type查询”和“复制”能力这两个“共性”,其它类型信息一概抹掉。这种“类型擦除”并不是真正的语言层面擦除的,正如我们已经看到的,这一切仍然是在 C++ 的类型检查系统中工作,维持着类型安全上的优点。
转自:http://www.cnblogs.com/liyiwen/archive/2009/12/10/1621451.html