C++对象模型之RTTI的实现原理

标签：c++对象模型   rtti实现原理   typeid   dynamic_cast   

class type_info
{
    public:
        virtual ~type_info();
        bool operator==(const type_info&)const;
        bool operator!=(const type_info&)const;
        bool before(const type_info&)const;
        const char* name()const;
    private:
        type_info(const type_info&);
        type_info& operator=(const type_info&);
       
        // data members
};

class X  {  ...... // 具有virtual函数 }; 
class XX : public X  { ...... // 具有virtual函数}; 
class Y  { ...... // 没有virtual函数}; 

int main()
{
    int n = 0;
    XX xx;
    Y y;
    Y *py = &y;

    // int和XX都是类型名
    cout << typeid(int).name() << endl;
    cout << typeid(XX).name() << endl;
    // n为基本变量
    cout << typeid(n).name() << endl;
    // xx所属的类虽然存在virtual，但是xx为一个具体的对象
    cout << typeid(xx).name() << endl;
    // py为一个指针，属于基本类型
    cout << typeid(py).name() << endl;
    // py指向的Y的对象，但是类Y不存在virtual函数
    cout << typeid(*py).name() << endl;
    return 0;
}

（1）一个指向不含有virtual函数的类对象的指针的解引用

（2）一个指向不含有virtual函数的类对象的引用

多态的类型是可以在运行过程中被改变的，例如，一个基类的指针，在程序运行的过程中，它可以指向一个基类对象，也可以指向该基类的派生类的对象，而typeid运算符需要在运行过程中识别出该基类指针所指向的对象的实际类型，这就需要typeid运算符在运行过程中计算其指向的对象的实际类型。例如对于以下的类定义：

class X
{
    public:
        X()
        {
            mX = 101;
        }
        virtual void vfunc()
        {
            cout << "X::vfunc()" << endl;
        }
    private:
        int mX;
};
class XX : public X
{
    public:
        XX():
            X()
        {
            mXX = 1001;
        }
        virtual void vfunc()
        {
            cout << "XX::vfunc()" << endl;
        }
    private:
        int mXX;
};

使用如下的代码进行测试：

void printTypeInfo(const X *px)
{
    cout << "typeid(px) -> " << typeid(px).name() << endl;
    cout << "typeid(*px) -> " << typeid(*px).name() << endl;
}
int main()
{
    X x;
    XX xx;
    printTypeInfo(&x);
    printTypeInfo(&xx);
    return 0;
}

其输出如下：

从输出的结果可以看出，无论printTypeInfo函数中指针px指向的对象是基类X的对象，还是指向派生类XX的对象，typeid运行返回的px的类型信息都是相同的，因为px为一个静态类型，其类型名均为PX1X。但是typeid运算符却能正确地计算出了px指向的对象的实际类型。（注：由于C++为了保证每一个类在程序中都有一个独一无二的类名，所以会对类名通过一定的规则进行改写，所以在这里显示的类名跟我们定义的有一些不一样，如类XX的类名，被改写成了2XX。）

那么问题来了，typeid是如何计算这个类型信息的呢？下面将重点说明这个问题。

多态类型是通过在类中声明一个或多个virtual函数来区分的。因为在C++中，一个具备多态性质的类，正是内含直接声明或继承而来的virtual函数。在C++对象模型之详述C++对象的内存布局一文中，已经详细地探讨了C++对象的内存布局，并说明了多态类的对象的类型信息保存在虚函数表的索引的-1的项中，该项是一个type_info对象的地址，该type_info对象保存着该对象对应的类型信息，每个类都对应着一个type_info对象。下面就对这一说法进行验证。

使用如以的代码，对上述的类X和类XX的对象的内存布局进行测试：

typedef void (*FuncPtr)();
int main()
{
    XX xx;
    FuncPtr func;
    char *p = (char*)&xx;
    // 获得虚函数表的地址
    int **vtbl = (int**)*(int**)p;
    // 输出虚函数表的地址，即vptr的值
    cout << vtbl << endl;
    // 获得type_info对象的指针，并调用其name成员函数
    cout << "\t[-1]: " << (vtbl[-1]) << " -> "
        << ((type_info*)(vtbl[-1]))->name() << endl;
    // 调用第一个virtual函数
    cout << "\t[0]: " << vtbl[0] << " -> ";
    func = (FuncPtr)vtbl[0];
    func();
    // 输出基类的成员变量的值
    p += sizeof(int**);
    cout << *(int*)p << endl;
    // 输出派生类的成员变量的值
    p += sizeof(int);
    cout << *(int*)p << endl;
    return 0;
}

测试代码，对类XX的对象的内存布局进行测试，其输出结果如下：

class X
{
    public:
        X()
        {
            mX = 101;
        }
    private:
        int mX;
};

class XX : public X
{
    public:
        XX():
            X()
        {
            mXX = 1001;
        }
    private:
        int mXX;
};

void printTypeInfo(const X *px)
{
    cout << "typeid(px) -> " << typeid(px).name() << endl;
    cout << "typeid(*px) -> " << typeid(*px).name() << endl;
}
int main()
{
    X x;
    XX xx;

    printTypeInfo(&x);
    printTypeInfo(&xx); // 注释1

    return 0;
}

class X
{
    public:
        X()
        {
            mX = 101;
        }
        virtual ~X()
        {
        }
    private:
        int mX;
};

class XX : public X
{
    public:
        XX():
            X()
        {
            mXX = 1001;
        }
        virtual ~XX()
        {
        }
    private:
        int mXX;
};

class YX : public X
{
    public:
        YX()
        {
            mYX = 1002;
        }
        virtual ~YX()
        {
        }
    private:
        int mYX;
};

int main()
{
    X x;
    XX xx;
    YX yx;

    X *px = &xx;
    cout << px << endl;

    XX *pxx = dynamic_cast<XX*>(px); // 转换1
    cout << pxx << endl;

    YX *pyx = dynamic_cast<YX*>(px); // 转换2
    cout << pyx << endl;

    pyx = (YX*)px; // 转换3
    cout << pyx << endl;

    pyx = static_cast<YX*>(px); // 转换4
    cout << pyx << endl;

    return 0;
}

C++对象模型之RTTI的实现原理

标签：c++对象模型   rtti实现原理   typeid   dynamic_cast   

原文地址：http://blog.csdn.net/ljianhui/article/details/46487951