第66课 C++中的类型识别

类型识别：

为什么引入类型识别呢？因为面向对象中有一个非常重要的原则就是赋值兼容性原则，就是子类对象完全可以当成父类对象使用。

当我们拿到指针p，我们知道它到底指向子类还是父类对象吗？

p的静态类型是Base，本意是期望指向Base对象，但是由于赋值兼容性，指针有可能指向子类对象，子类对象在这里是动态类型。

想要安全的转换就要得到b实际指向的动态类型，我们需要提前判断动态类型是什么。

 

C++中如何得到动态类型呢？

 示例程序：

#include <iostream>
#include <string>

using namespace std;

class Base
{
public:
    virtual string type()
    {
        return "Base";
    }
};

class Derived : public Base
{
public:
    string type()
    {
        return "Derived";
    }
    
    void printf()
    {
        cout << "I'm a Derived." << endl;
    }
};

class Child : public Base
{
public:
    string type()
    {
        return "Child";
    }
};

void test(Base* b)
{
    /* 危险的转换方式 */
    // Derived* d = static_cast<Derived*>(b);
    
    if( b->type() == "Derived" )
    {
        Derived* d = static_cast<Derived*>(b);
        
        d->printf();
    }
    
    // cout << dynamic_cast<Derived*>(b) << endl;
}


int main(int argc, char *argv[])
{
    Base b;
    Derived d;
    Child c;
    
    test(&b);
    test(&d);
    test(&c);
    
    return 0;
}

运行结果如下：

我们不仅需要知道dynamic_cast转换是不是成功，还需要知道具体的类型到底是什么，因此，dynamic_cast在这里不够用。

虚函数返回类型的方式能解决问题，但是不够好，当我们增加新类时容易和以前的重复或者混淆。

多态解决方案的缺陷：

C++的解决方案：

 示例程序：

#include <iostream>
#include <string>
#include <typeinfo>

using namespace std;

class Base
{
public:
    virtual ~Base()
    {
    }
};

class Derived : public Base
{
public:
    void printf()
    {
        cout << "I'm a Derived." << endl;
    }
};

void test(Base* b)
{
    const type_info& tb = typeid(*b);
    
    cout << tb.name() << endl;
}

int main(int argc, char *argv[])
{
    int i = 0;
    
    const type_info& tiv = typeid(i);
    const type_info& tii = typeid(int);
    
    cout << (tiv == tii) << endl;
    
    Base b;
    Derived d;
    
    test(&b);
    test(&d);
    
    return 0;
}

typeid返回的是对象，这个对象的类型在typeinfo库中。

 BCC中的输出如下：

可见，typeid在不同系统中的实现时不一样的，我们不能假设typeid的实现。

小结：