转载请注明出处:http://www.cnblogs.com/inevermore/p/4012079.html
RTTI,指的是运行时类型识别技术。
先看一个貌似无关的问题:
为继承体系重载<<操作符
有下面的一个继承体系,我们需要为其添加输出操作符,应该怎么办:
class Animal { }; class Cat : public Animal { }; class Dog : public Animal { };
我们的第一个办法就是为每个类添加operator<<函数,但是我们也可以尝试这样:
class Animal { public: virtual string toString() const = 0; }; class Cat : public Animal { public: string toString() const { return "Cat"; } }; class Dog : public Animal { string toString() const { return "Dog"; } }; ostream &operator<<(ostream &os, const Animal &a) { return os << a.toString(); }
显然我们只提供了一个基类的输出运算符,但是因为const Animal &a的缘故,所有子类都可以放入。那么如果根据不同的类型打印不同的内容呢,我们使用了多态。
这样做的好处是什么?如果采用每个类都提供输出运算符的方案,那么我们必须牢记,每编写一个类就要为其添加一个操作符,这一点是很容易遗忘的,但是如果采用我们上面的代码,我们将toString写为虚函数,这样,我们每次去重新实现toString就可以了。虚函数被遗忘的可能性比<<操作符低很多。
为继承体系重载==操作符
还是之前的类:
class Animal { }; class Cat : public Animal { }; class Dog : public Animal { };
这次我们需要为其提供==操作符,那么我们应该提供几个?为每个类提供一个显然是不够的,因为继承体系中,派生类对象可以被基类对象引用,所以我们有时候需要将Animal &与Cat &进行比较。
bool operator==(const Animal &, const Animal &); bool operator==(const Cat &, const Cat &); bool operator==(const Dog &, const Dog &); bool operator==(const Animal &, const Cat &); bool operator==(const Cat &, const Dog &); //.............
看起来,五个还不够。就算只有五个,我们需要逐个实现也是非常恐怖。那么有没有好一些的解决方案呢?我们采用本文第一节的技巧。
只重载一个Animal基类的==操作符
每个类实现equal,这是一个虚函数
在继续编写代码之前,我们先搞清楚,两个相同的前提是,他们的类型相同,然后再去比较成员变量。
于是我们给出的解决方案如下:
#include <iostream> #include <typeinfo> #include <string> using namespace std; class Animal { public: virtual bool equal(const Animal &other) const = 0; }; class Cat : public Animal { public: bool equal(const Animal &other) const { //Cat Animal if(const Cat *pc = dynamic_cast<const Cat*>(&other)) { return name_ == pc->name_; } return false; } private: string name_; }; class Dog : public Animal { public: bool equal(const Animal &other) const { //Dog Animal if(const Dog *pd = dynamic_cast<const Dog*>(&other)) { return name_ == pd->name_; } return false; } private: string name_; }; bool operator==(const Animal &a, const Animal &b) { return typeid(a) == typeid(b) && a.equal(b); } int main(int argc, char const *argv[]) { Cat c; Dog d; Animal *pa = &c; cout << (*pa == c) << endl; pa = &d; cout << (*pa == d) << endl; return 0; }
我们先来看<<的重载:
bool operator==(const Animal &a, const Animal &b) { return typeid(a) == typeid(b) && a.equal(b); }
这里利用了&&的短路特性,一旦两个对象的类型不同,那么后面就没有必要比较。
typeid是一个类型识别运算符,如果要识别的类型不是class或者不含有virtual函数,那么typeid指出静态类型。如果class含有虚函数,那么typeid在运行期间识别类型。
对equal的调用,显然使用了动态绑定,总是根据对象的实际类型调用对应的equal版本。
然后我们看一下Dog中equal的实现:
bool equal(const Animal &other) const { //Cat Animal if(const Cat *pc = dynamic_cast<const Cat*>(&other)) { return name_ == pc->name_; } return false; }
这里利用了dynamic_cast进行了“向下塑形”,dynamic_cast与static_cast有一些不同:
static_cast发生在编译期间,如果转化不通过,那么编译错误,如果编译无问题,那么转化一定成功。static_cast仍具有一定风险,尤其是向下塑形时,将Base*转化为Derived*时,指针可以转化,但是指针未必指向Derived对象。
dynamic_cast发生在运行期间,用于将Base的指针或者引用转化为派生类的指针或者引用,如果成功,返回正常的指针或引用,如果失败,返回NULL(指针),或者抛出异常(bad_cast)。
在<<的重载中,我们保证了equal两个参数的类型相同,那么我们为何还需要在equal中“向下塑形”呢?
equal有可能被单独使用,所以other的类型未必和自己相同。
如果不进行转换,other是无法访问name属性的,因为Animal中没有name。
记住下面的代码:
//pb是Base类型指针 if(Derived *pd = dynamic_cast<Derived*>(pb)) { //转化成功 } else { //失败 }
这是一种使用dynamic_cast的标准实践。
这段代码的逻辑是非常严密的:
pd的生存期只存在于转化成功的情况
无法在dynamic_cast和测试代码之间插入代码
如果使用的是引用,可以这样:
try { const Derived &d = dynamic_cast<const Derived&>(b); //成功 } catch(bad_cast) { //失败处理 }
也可以将引用取地址,然后去转化指针。
typeid和dynamic_cast是实现RTTI的主要手段。
完毕。