C++ 的 RTTI 可以删掉了

一两年没碰编程了，最近开始写一个程序，写的过程中想到了一些东西。

 

看这段代码

 

class InterfaceSample { void * content; int (*invoker)(void *,int); void (*deleter)(void *); template <class Type> static void Deleter(void * content) { delete (Type *)content; } template <class Type> static int Invoker(void * content,int bearNum) { return ((Type *)content) -> killTheBear( bearNum ); } public: InterfaceSample() : content(0){} template <class Type> InterfaceSample( Type & inContent ) { content = new Type(inContent); invoker = Invoker<Type>; deleter = Deleter<Type>; } template <class Type> InterfaceSample & operator = ( Type & inContent ) { if (content) (*deleter)(content); content = new Type(inContent); invoker = Invoker<Type>; deleter = Deleter<Type>; return *this; } #ifdef _CPP_0X template <class Type> InterfaceSample( Type && inContent ) { content = new Type(std::move(inContent)); invoker = Invoker<Type>; deleter = Deleter<Type>; } template <class Type> InterfaceSample &operator = ( Type && inContent ) { if (content) deleter(content); content = new Type(std::move(inContent)); invoker = Invoker<Type>; deleter = Deleter<Type>; return *this; } #endif int killTheBear(int bearNum) { if ( !content ) return 0; return (*invoker)(content,bearNum); } ~InterfaceSample() { if (content) (*deleter)(content); } };

 

这个一个用模板实现的协议类，拥有一个虚成员函数和一个虚析构函数，其功能可以用以下代码来测试

 #include <iostream> //基类 class Parent { public: int killTheBear(int bearNum) { std::cout << bearNum << '/n'; return bearNum; } ~Parent() { std::cout << "goobye parent!/n"; } }; //子类 class Child : public Parent { int num ; public: Child():num(2){} int killTheBear(int bearNum) { std::cout << bearNum*num << '/n'; return bearNum*num; } ~Child() { std::cout << "goobye child!/n"; } }; //子函数对像 class LoveChild { public: struct{ int operator () ( int bearNum){ std::cout << bearNum*bearNum << '/n'; return bearNum*bearNum; } }killTheBear; }; int _tmain(int argc, _TCHAR* argv[]) { Parent parent; Child child; LoveChild loveChild; std::cout << "直接调用/n"; parent.killTheBear(4); child.killTheBear(4); loveChild.killTheBear(4); std::cout << "虚函数调用/n"; InterfaceSample sample; sample = parent; sample.killTheBear(4); sample = child; sample.killTheBear(4); sample = loveChild; sample.killTheBear(4); char key; std::cin >> key; return 0; }

 

和协议类有点不同，这里的模板协议类语义上并不是指针，是不是省心很多？有了新标准的move语意的话，性能上也不会有什么问题。

这只是个很简单的实现，但已具有了一个协议类几乎所有的功能，并且在通用性上远高于协议类，它可以接受任意类型的对像，而不用考虑任何继承关系，唯一的要求只是付与的对像拥有看起来像是“int killTheBear(int)”这样的成员。

 

如果写成这样

 

void putInAny(InterfaceSample children){ children.killTheBear(4); }

 

这样一个函数既有泛型函数通用任何类型，同时类型安全的特点，又像普通函数一样有函数体，有2进制接囗，你甚至可以把它放在一个DLL中输出，可以算是“运行时泛型”吧。

 

下面是之后写的一个复杂一些的实现，有了全局的虚函数表，其中有两个子函数接口，一个虚析构函数，一个虚operator=()，一个代表类型的整型数值，若特化了TypeId模板，还可以实现dynamic_cast<type>语义。

 

 template <class Type> struct TypeId { enum { id = 0}; }; class InterfaceVT{ typedef void (* Invoker1) (void*,int); typedef int (* Invoker2) (void*,int,int); typedef void* (* Clone) (void*); typedef void (* Deleter) (void *); struct VTable{ Invoker1 invoker1; Invoker2 invoker2; Clone clone; Deleter deleter; int id; }; void *content; VTable *vTable; template<class Type> static void invoker1 (void* content,int num) { ((Type *)content)->method1(num); } template<class Type> static int invoker2 (void* content,int num1,int num2) { return ((Type *)content)->method2(num1,num2); } template<class Type> static void * clone (void* other) { return new Type(*(Type *)other); } template<class Type> static void deleter (void * content) { delete (Type *)content; } template<class Type> static VTable * vTableContener() { static VTable contening = {invoker1<Type>,invoker2<Type>,clone<Type>,deleter<Type>,TypeId<Type>::id}; return & contening; } public: InterfaceVT():content(0){} InterfaceVT( InterfaceVT & other ) { vTable = other.vTable; content = vTable->clone(other.content); } InterfaceVT & operator = ( InterfaceVT & other ) { if (content) (*vTable->deleter)(content); vTable = other.vTable; content = vTable->clone(other.content); return *this; } template <class Type> InterfaceVT( Type & inContent ) { content = new Type(inContent); vTable = vTableContener<Type>(); } template <class Type> InterfaceVT & operator = ( Type & inContent ) { if (content) (*vTable->deleter)(content); content = new Type(inContent); vTable = vTableContener<Type>(); return *this; } #ifdef _CPP_0X template <class Type> InterfaceVT( Type && inContent ) { content = new Type(std::move(inContent)); invoker = Invoker<Type>; deleter = Deleter<Type>; } template <class Type> InterfaceVT & operator = ( Type && inContent ) { if (content) (*vTable->deleter)(content); content = new Type(std::move(inContent)); vTable = vTableContener<Type>(); return *this; } #endif template <class Type> friend Type * IVTDynamic_cast(InterfaceVT & ivt) { if ( !ivt.vTable->id ) return 0; if ( ivt.vTable->id != TypeId<Type>::id) return 0; return (Type *) ivt.content; } void method1(int num) { if ( !content ) return; (*vTable->invoker1)(content,num); } int method2(int num1,int num2) { if ( !content ) return 0; return (*vTable->invoker2)(content,num1,num2); } ~InterfaceVT() { if ( content ) vTable->deleter( content); } };

 

可以通过下面代码来测试

 

class ABear { public: void method1 (int num) { std::cout << num << '/n'; } struct { int operator()(int num1,int num2) { std::cout << num1+num2 << '/n'; return num1+num2; } }method2; ~ABear() { std::cout << "goodbye/n"; char key; std::cin >> key; } }; template<> struct TypeId<ABear> { enum { id = 12345}; }; int _tmain(int argc, _TCHAR* argv[]) { std::cout << "直接调用/n"; ABear aBear; aBear.method1(7); aBear.method2(6,9); std::cout << "虚函数调用/n"; InterfaceVT vTable; vTable = aBear; vTable.method1(7); vTable.method2(6,9); std::cout << "考贝/n"; InterfaceVT vTable1; vTable1 = vTable; vTable1.method1(7); vTable1.method2(6,9); std::cout << "dynamic_cast/n"; ABear * bear = IVTDynamic_cast<ABear>( vTable ); (*bear).method1(7); (*bear).method2(6,9); return 0; }

 

如果说当时C++引进RTTI是回为用C原有的语法不能实现相应的功能，那么现在看来RTTI不过是模板功能的一个小子集，而且还是不完整的一个子集，那么RTTI是不是该从C++中扔掉了？

 

至少有个编译选项可以关掉RTTI和联带的一些带来坏影响的特性，那么在我们需要更好的功能和安全性，而代码量却不是关键时，也是个不错的选择吧。