66-C++中的类型识别

注：博客中内容主要来自《狄泰软件学院》，博客仅当私人笔记使用。

测试环境：Ubuntu 10.10

GCC版本：9.2.0

 

一、类型识别

1) 在面向对象中可能出现下面的情况

        -    基类指针指向子类对象

        -    基类引用成为了子类对象的别名

无法判断p指向父类对象还是子类对象。p期望指向Base*（父类）

 

2) 静态类型—变量（对象）自身的类型(写代码时就能确定类型)

3) 动态类型—指针（引用）所指向对象的实际类型

 

问题

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

 

二、动态类型识别

1) 解决方案—利用多态

    1、在基类中定义虚函数返回具体的类型信息

    2、所有的派生类都必须实现类型相关的虚函数

    3、每个类中的类型虚函数都需要不同的实现

编程实验
动态类型识别
66-1.cpp
#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);
}


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

操作：

1) g++ 66-1.cpp -o 66-1.out编译正确

分析：

        虽然编译正确，但是test()中Derived* d = static_cast<Derived*>(b);的b是父类要转换成指定子类。

 

2) 解决上述问题办法：

void test(Base* b)
{
    //判断是我们期望的类型？
    if( b->type() == "Derived" )    //能解决，但维护性不好
    {
        Derived* d = static_cast<Derived*>(b);    
        
        d->printf();
    }
}

g++  66-1.cpp -o 66-1.out编译正确，打印结果：

I'm a Derived.

分析：

        用staic_cast<Derived*>进行转换不好，这里有继承关系，而且还有虚函数用dynamic_cast<>转换更好。

void test(Base* b)
{  
    if( b->type() == "Derived" )    //能解决，但维护性不好
    {
        Derived* d = static_cast<Derived*>(b);
        
        d->printf();
    }
    
    cout << dynamic_cast<Derived*>(b) << endl;    //测试一（我们需的不只是转换成功，还需要具体类型）
}

g++  66-1.cpp -o 66-1.out编译正确，打印结果：

0(dynamic_cast转换失败)
I'm a Derived.
0xbfc57248    //dynamic_cast转换成功
0(dynamic_cast转换失败)

 

2) 多态解决方案的缺陷

    -    必须从基类开始提供类型虚函数

    -    所有的派生类都必须重写类型虚函数

    -    每个派生类的类型名必须唯一

 

三、类型识别关键字

1) C++提供了typeid关键字用于获取类型信息

    -    typeid关键字返回对应参数的类型信息

    -    typeid返回一个type_info类对象

    -    当typeid的参数为NULL时将抛出异常

 

2) typeid关键字的使用

int i = 0;

const type_info& tiv = typeid(i);
const type_info& tii = typeid(int);

cout << (tiv == tii) << endl;
结论：相等

 

四、动态类型识别

1) typeid的注意事项

    -    当参数为类型时：返回静态类型信息

    -    当参数为变量时：

        *不存在虚函数表-返回静态类型信息

        *存在虚函数表-返回动态类型信息

编程实验
typeid类型识别
66-2.cpp
#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;
}

操作：

1) g++ 66-2.cpp -o 66-2.out编译正确，打印结果：

1
4Base
4Base

分析：

        父类退化为子类，导致都打印4Base。

解决办法在父类Base中定义虚函数：

#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;
}

g++ 66-2.cpp -o 66-2.out编译正确，打印结果：

1
4Base
7Derived

分析：

        增加virtual，这里防止子类退化为父类，能够正常识别指针类型。

 

小结

1) C++中有静态类型和动态类型的概念

2) 利用多态能够实现对象的动态类型识别

3) typeid是专用于类型识别的关键字

4) typeid能够返回对象的动态类型信息