typeid and dynamic_cast

1.typeid可以获取一个变量的类型名称，例如：ClassA  a; typeid(a).name();

可以用于在运行期判断变量的类型。在实现上每个编译器都有自己的实现方法，一般的C++的编译器的实现可分为两种不同情况：

①静态类型

②动态类型

对于静态类型的变量，比如基本类型（int，float等）、类的对象以及非多态的类的指针，像这种变量，都是可以在编译期就确定变量类型的（推导类型是编译器的基本能力），因此凡是出现typeid的地方，编译器就会生成一份typeinfo结构体，存放这个变量类型的信息。

对于动态类型，比如：F* f = new S;那么假设想通过typeid判断*f的类型，也是可以的（typeid(*f).name()结果和typeid(S).name()相同)，在实现上编译器会为每个多态类创建一份typeinfo（同样是在编译期实现的），然后将其地址放到这个类的虚函数表的前面size_t个字节。这样就能通过虚函数表找到这个typeinfo的信息。测试代码如下所示：

#include<iostream>
#include <typeinfo>
using namespace std;

class F {

    public:
        virtual void AA() {
            cout << "F::AA()" << endl;
        }
        virtual void BB() {
            cout << "F::BB()" << endl;
        }
        void CC(){
            cout << "F::CC()" << endl;
            
        }
        virtual void FF() {
            cout << "F::FF()" << endl;
        
        }
};

class S : public F {
    public:
        virtual void BB() {
            
            cout << "S::BB()" << endl;
        }
        virtual void DD() {
        
            cout << "S::DD()" << endl;
        }

        void EE() {
        
            cout << "S::EE()" << endl;
        }
    
};
int main() {

    F* f = new S;
    typedef void(*pFun)();
    pFun* p = (pFun*)*(size_t*)f;　    　//虚函数表首地址
    p--;                                //typeinfo信息地址 
    type_info *base = (type_info *)(*p);//*p也是个指针，且其指向的内存是type_info结构体(准确的说应该是这块内存前面的信息是type_info结构体，后面可能有别的信息)
    cout << base->name() << endl;
    cout << typeid(S).name() << endl;
    p++;
    (*p)();//调用虚函数表中的函数
    p++;
    (*p)();
    p++;
    (*p)();
    p++;
    (*p)();
    
    return 0;
}

运行结果如下：

1S
1S
F::AA()
S::BB()
F::FF()
S::DD()

可以看到虚函数表前面的地址存储的就是typeinfo的地址，后面存储的就是函数指针了。

一些疑问：

①这个typeinfo信息到底被存在哪？由于其是在编译期产生的，应该存储在静态存储区（全局变量区）或者常量区。

②虚函数表只存储了函数指针，那么在调用时如何知道这个索引值（例如上面的例子，加入你调用f->BB()，那么怎么知道取的是虚函数表中的第二个函数呢？），这个也是编译器帮我们做的记录，编译器会在编译期记录虚函数的排列顺序，这样调用的时候就能知道index值了。

注：以上代码运行环境为：ubuntu16.04 + gcc5.4.0，在vs上不能成功运行（vs默认使用的是MSVC编译器，不同的编译器在实现RTTI上是不同的，MSVC在实现上存储的是一个rtti complete object locator结构体指针，位置同样是在vtable的前面，下面会有测试代码，来自：http://www.cppblog.com/dawnbreak/archive/2009/03/12/76354.html）

#include "iostream"
#include "string"


using namespace std;
class Aclass
{
public:
	int a;
	virtual void setA(int tmp)
	{
		a=tmp;
		cout<<a<<endl;
	}
};
class Bclass:public Aclass
{
public:
	virtual void setA(int tmp)
	{
		a=tmp+10;
		cout<<a<<endl;
	}
public:
	void print()
	{
		cout<<a<<endl;
	}
};
class Cclass:public Bclass
{
};
typedef unsigned long DWORD;
struct TypeDescriptor
{
	DWORD ptrToVTable;
	DWORD spare;
	char name[8];
};
struct PMD
{

	int mdisp;  //member displacement

	int pdisp;  //vbtable displacement

	int vdisp;  //displacement inside vbtable

};
struct RTTIBaseClassDescriptor

{

	struct TypeDescriptor* pTypeDescriptor; //type descriptor of the class

	DWORD numContainedBases; //number of nested classes following in the Base Class Array

	struct PMD where;        //pointer-to-member displacement info

	DWORD attributes;        //flags, usually 0

};

struct RTTIClassHierarchyDescriptor
{

	DWORD signature;      //always zero?

	DWORD attributes;     //bit 0 set = multiple inheritance, bit 1 set = virtual inheritance

	DWORD numBaseClasses; //number of classes in pBaseClassArray

	struct RTTIBaseClassArray* pBaseClassArray;

};

struct RTTICompleteObjectLocator

{

	DWORD signature; //always zero ?

	DWORD offset;    //offset of this vtable in the complete class

	DWORD cdOffset;  //constructor displacement offset

	struct TypeDescriptor* pTypeDescriptor; //TypeDescriptor of the complete class

	struct RTTIClassHierarchyDescriptor* pClassDescriptor; //describes inheritance hierarchy


};


int main(int argc, char* argv[])
{
	Aclass* ptra=new Bclass;
	int ** ptrvf=(int**)(ptra);

	RTTICompleteObjectLocator str=
		*((RTTICompleteObjectLocator*)(*((int*)ptrvf[0]-1)));
	//abstract class name from RTTI
	string classname(str.pTypeDescriptor->name);
	//classname=classname.substr(4,classname.find("@@")-4);
	cout<<classname<<endl;
	system("pause");
	return 0;
}

在MSVC的编译器上多态对象内存布局如下图所示：

与g++不同的是，vtable前面存储的是rtti complete object locator结构体指针（通过vs的单步调试可以看到），其内部包含一个pTypeDescriptor指针和pClassDescriptor指针，pTypeDescriptor结构体内就包含对象的类名，就能实现typeid的功能。

 

2.dynamic_cast

　　由上图可知，rtti complete object locator结构体中还包含pClassDescriptor结构体，其内包含对象的父类信息pBaseClassArray，父类信息再向上又能找到父类的父类的信息，相当于维护了一个继承关系树，也就是说能通过当前对象知道这个类的所有父类的信息。

　　这样当你写下dynamic_cast<Bclass*>(ptra)时，就能知道ptra这个指针指向的对象到底是不是Bclass或者是Bclass的子类，是的话就返回对象地址，否则就返回空指针，实现了安全的类型转换。

　　至于g++，其实现逻辑如下：

　　①找到 ptra的 type_info，找到Bclass的type_info（静态推导即可）

　　②判断ptra的类型与Bclass是否相等或者是否是其子类

　　③是：返回对象地址；否返回空指针

疑问：假设ptra的类型是 Bclass的子类，而非Bclass自身，那么g++的实现是怎么判断ptra是否是Bclass的子类的。

可以有两种做法：

①像MSVC一样，除了存储自身类型信息外，在后面存储上父类的类型信息（前面验证了vtable前面的指针指向的内存起始内容是个type_info结构体，后面是否存了其他信息没有找到依据）

②编译器在编译期确定这个继承关系链

总之无论如何实现，都避免不了维护这个继承关系链

小结：

1.typeid分静态推导和动态推导，且不同编译器有不同的实现，如果是动态推导，typeid的实现原理等同于RTTI，但是typeid只确定自己的类型信息，无需更多的判断，代价相比dynamic_cast要小

2.dynamic_cast一般用于多态类型的向下类型转换，作用对象的范围比typeid小，实现复杂，运行代价一般比typeid大

 

转载于:https://www.cnblogs.com/deepllz/p/10022178.html