dynamic_cast实现原理

最新推荐文章于 2024-05-10 14:25:03 发布
最新推荐文章于 2024-05-10 14:25:03 发布
阅读量2.5k 收藏 5
点赞数 1
分类专栏： c++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LIJIWEI0611/article/details/120699526
版权

在使用dynamic_cast时，查看的反汇编，假设C是派生类，A是基类

 A* pa = new C;
  C * c = dynamic_cast<C *>(pa); 

其中调用了___RTDynamicCast，

在http://en.verysource.com/winceos-99192.html 中有

其中便有其实现，为了不和编译器中的 ___RTDynamicCast冲突，新建两个文件：rtti.h和rtti.cpp,将___RTDynamicCast修改为___RTDynamicCastMY,并注释掉一些抛异常。内容如下：

rtti.h

#pragma once

extern "C" {
#include <windows.h>
};

typedef const type_info TypeDescriptor;

struct PMD
{
  ptrdiff_t mdisp; //vftable offset
  ptrdiff_t pdisp; //vftable offset
  ptrdiff_t vdisp; //vftable offset(for virtual base class)
};

typedef const struct _s_RTTIBaseClassDescriptor
{
  TypeDescriptor                  *pTypeDescriptor;
  DWORD                           numContainedBases;
  PMD                             where;
  DWORD                           attributes;
} _RTTIBaseClassDescriptor;

typedef const struct  _s_RTTIBaseClassArray
{
  _RTTIBaseClassDescriptor* arrayOfBaseClassDescriptors[3];
}_RTTIBaseClassArray;

typedef const struct _s_RTTIClassHierarchyDescriptor
{
  DWORD                           signature;
  DWORD                           attributes;
  DWORD                           numBaseClasses;
  _RTTIBaseClassArray             *pBaseClassArray;
}_RTTIClassHierarchyDescriptor;

typedef const struct _s_RTTICompleteObjectLocator
{
  DWORD                           signature;
  DWORD                           offset;			 //vftbl相对this的偏移
  DWORD                           cdOffset;		 //constructor displacement 
  TypeDescriptor                  *pTypeDescriptor;
  _RTTIClassHierarchyDescriptor   *pClassDescriptor;
}_RTTICompleteObjectLocator;

#define BCD_NOTVISIBLE              0x00000001
#define BCD_AMBIGUOUS               0x00000002
#define BCD_PRIVORPROTINCOMPOBJ     0x00000004
#define BCD_PRIVORPROTBASE          0x00000008
#define BCD_VBOFCONTOBJ             0x00000010
#define BCD_NONPOLYMORPHIC          0x00000020

#define BCD_PTD(bcd)                ((bcd).pTypeDescriptor)
#define BCD_NUMCONTBASES(bcd)       ((bcd).numContainedBases)
#define BCD_WHERE(bcd)              ((bcd).where)
#define BCD_ATTRIBUTES(bcd)         ((bcd).attributes)

#define CHD_MULTINH                 0x00000001 //多重继承
#define CHD_VIRTINH                 0x00000002 //虚拟继承
#define CHD_AMBIGUOUS               0x00000004 //有重复基类的多重继承

#define CHD_SIGNATURE(chd)          ((chd).signature)
#define CHD_ATTRIBUTES(chd)         ((chd).attributes)
#define CHD_NUMBASES(chd)           ((chd).numBaseClasses)
#define CHD_PBCA(chd)               ((chd).pBaseClassArray)

#define COL_SIGNATURE(col)          ((col).signature)
#define COL_OFFSET(col)             ((col).offset)
#define COL_CDOFFSET(col)           ((col).cdOffset)
#define COL_PTD(col)                ((col).pTypeDescriptor)
#define COL_PCHD(col)               ((col).pClassDescriptor)

extern "C" PVOID __cdecl __RTDynamicCastMY(PVOID, LONG, PVOID, PVOID, BOOL);

extern "C" PVOID __cdecl __RTtypeidMY(PVOID);     // ptr to vfptr

#define TYPEIDS_EQ(pID1, pID2)  ((pID1 == pID2) || !strcmp(pID1->name(), pID2->name()))

rtti.cpp

#include <stdio.h>
#include <typeinfo>
#include "rtti.h"
 
#pragma warning(disable:4297)
 
static PVOID __cdecl FindCompleteObject(PVOID *);
static _RTTIBaseClassDescriptor * __cdecl FindSITargetTypeInstance(PVOID,_RTTICompleteObjectLocator *,TypeDescriptor *,int,TypeDescriptor *);
static _RTTIBaseClassDescriptor * __cdecl FindMITargetTypeInstance(PVOID,_RTTICompleteObjectLocator *,TypeDescriptor *,int,TypeDescriptor *);
static _RTTIBaseClassDescriptor * __cdecl FindVITargetTypeInstance(PVOID,_RTTICompleteObjectLocator *,TypeDescriptor *,int,TypeDescriptor *);
static ptrdiff_t __cdecl PMDtoOffset(PVOID pThis, const PMD& pmd);
 
extern "C" PVOID __cdecl __RTtypeidMY (PVOID inptr)         
{
    if (!inptr) {
        //throw std::bad_typeid ("Attempted a typeid of NULL pointer!"); 
        return NULL;
    }
 
    __try {
        // Ptr to CompleteObjectLocator should be stored at vfptr[-1]
        _RTTICompleteObjectLocator *pCompleteLocator = (_RTTICompleteObjectLocator *) ((*((void***)inptr))[-1]);
        return (PVOID) pCompleteLocator->pTypeDescriptor;
    }
    __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER:		        EXCEPTION_CONTINUE_SEARCH) 
	{
        //throw std::__non_rtti_object ("Access violation - no RTTI data!");
    }
}
 
 
extern "C" PVOID __cdecl __RTDynamicCastMY (
                                        PVOID inptr,         // Pointer to polymorphic object
                                        LONG VfDelta,       // Offset of vfptr in object
                                        PVOID SrcType,      // Static type of object pointed to by inptr
                                        PVOID TargetType,   // Desired result of cast
                                        BOOL isReference)   // TRUE if input is reference, FALSE if input is ptr
{
    PVOID pResult;
    _RTTIBaseClassDescriptor *pBaseClass;
 
    if (inptr == NULL)
        return NULL;
 
    __try {
        PVOID pCompleteObject = FindCompleteObject((PVOID *)inptr);
        _RTTICompleteObjectLocator *pCompleteLocator = (_RTTICompleteObjectLocator *) ((*((void***)inptr))[-1]);
 
        // Adjust by vfptr displacement, if any
        inptr = (PVOID *) ((char *)inptr - VfDelta);
        // Calculate offset of source object in complete object
        int inptr_delta = (char *)inptr - (char *)pCompleteObject;
 
        if (!(CHD_ATTRIBUTES(*COL_PCHD(*pCompleteLocator)) & CHD_MULTINH)) {             // if not multiple inheritance
            pBaseClass = FindSITargetTypeInstance(pCompleteObject,
                                                  pCompleteLocator,
                                                  (TypeDescriptor *) SrcType,
                                                  inptr_delta,
                                                  (TypeDescriptor *) TargetType);
        } else if (!(CHD_ATTRIBUTES(*COL_PCHD(*pCompleteLocator)) & CHD_VIRTINH)) { // if multiple, but not virtual, inheritance
            pBaseClass = FindMITargetTypeInstance(pCompleteObject,
                                                  pCompleteLocator,
                                                  (TypeDescriptor *) SrcType,
                                                  inptr_delta,
                                                  (TypeDescriptor *) TargetType);
        } else {                                                                   // if virtual inheritance
            pBaseClass = FindVITargetTypeInstance(pCompleteObject,
                                                  pCompleteLocator,
                                                  (TypeDescriptor *) SrcType,
                                                  inptr_delta,
                                                  (TypeDescriptor *) TargetType);
        }
 
        if (pBaseClass != NULL) {
            // Calculate ptr to result base class from pBaseClass->where
            pResult = ((char *) pCompleteObject) + PMDtoOffset(pCompleteObject, pBaseClass->where);
        }else {
            pResult = NULL;
            if (isReference) {
              //  throw std::bad_cast("Bad dynamic_cast!");
            }
        }
 
    }
    __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER: EXCEPTION_CONTINUE_SEARCH) {
        pResult = NULL;
       // throw std::__non_rtti_object ("Access violation - no RTTI data!");
    }
 
    return pResult;
        
}
 
//
// FindCompleteObject - Calculate member offset from PMD & this
//
// Output: pointer to the complete object containing class *inptr
//
// Side-effects: NONE.
//
static PVOID __cdecl FindCompleteObject (PVOID *inptr)          // Pointer to polymorphic object
{
    // Ptr to CompleteObjectLocator should be stored at vfptr[-1]
    _RTTICompleteObjectLocator *pCompleteLocator = (_RTTICompleteObjectLocator *) ((*((void***)inptr))[-1]);
    char *pCompleteObject = (char *)inptr - pCompleteLocator->offset;
    // Adjust by construction displacement, if any
    if (pCompleteLocator->cdOffset)
        pCompleteObject += *(ptrdiff_t *)((char *)inptr - pCompleteLocator->cdOffset);
    return (PVOID) pCompleteObject;
}
 
static _RTTIBaseClassDescriptor * __cdecl FindSITargetTypeInstance (
                                PVOID pCompleteObject,                          // pointer to complete object
                                _RTTICompleteObjectLocator *pCOLocator, // pointer to Locator of complete object
                                TypeDescriptor *pSrcTypeID,        // pointer to TypeDescriptor of source object
                                int SrcOffset,                                          // offset of source object in complete object
                                TypeDescriptor *pTargetTypeID)     // pointer to TypeDescriptor of result of cast
{
    _RTTIBaseClassDescriptor *pBase;
    _RTTIBaseClassDescriptor * const *pBasePtr;
    DWORD i;
 
    for (i = 0, pBasePtr = pCOLocator->pClassDescriptor->pBaseClassArray->arrayOfBaseClassDescriptors;
         i < pCOLocator->pClassDescriptor->numBaseClasses;
         i++, pBasePtr++) {
 
        // Test type of selected base class
        pBase = *pBasePtr;
        if (TYPEIDS_EQ(pBase->pTypeDescriptor, pTargetTypeID) &&
            !(BCD_ATTRIBUTES(*pBase) & BCD_NOTVISIBLE)) {
            return pBase;
        }
    }
    return NULL;
}
 
static _RTTIBaseClassDescriptor * __cdecl FindMITargetTypeInstance (
                                PVOID pCompleteObject,                          // pointer to complete object
                                _RTTICompleteObjectLocator *pCOLocator, // pointer to Locator of complete object
                                TypeDescriptor *pSrcTypeID,        // pointer to TypeDescriptor of source object
                                int SrcOffset,                                          // offset of source object in complete object
                                TypeDescriptor *pTargetTypeID)     // pointer to TypeDescriptor of result of cast
{
    _RTTIBaseClassDescriptor *pBase, *pSubBase;
    _RTTIBaseClassDescriptor * const *pBasePtr, * const *pSubBasePtr;
    DWORD i, j;
 
                                // First, try down-casts
    for (i = 0, pBasePtr = pCOLocator->pClassDescriptor->pBaseClassArray->arrayOfBaseClassDescriptors;
         i < pCOLocator->pClassDescriptor->numBaseClasses;
         i++, pBasePtr++) {
        
        pBase = *pBasePtr;
                                // Test type of selected base class
        if (TYPEIDS_EQ(pBase->pTypeDescriptor, pTargetTypeID)) {
                                // If base class is proper type, see if it contains our instance of source class
            for (j = 0, pSubBasePtr = pBasePtr+1;
                 j < pBase->numContainedBases;
                 j++, pSubBasePtr++) {
 
                pSubBase = *pSubBasePtr;
                if (TYPEIDS_EQ(pSubBase->pTypeDescriptor, pSrcTypeID) &&
                    (PMDtoOffset(pCompleteObject, pSubBase->where) == SrcOffset)) {
                                // Yes, this is the proper instance of source class
                    return pBase;
                }
            }
        }
    }
 
                                // Down-cast failed, try cross-cast
    for (i = 0, pBasePtr = pCOLocator->pClassDescriptor->pBaseClassArray->arrayOfBaseClassDescriptors;
         i < pCOLocator->pClassDescriptor->numBaseClasses;
         i++, pBasePtr++) {
 
        pBase = *pBasePtr;
                                // Check if base class has proper type, is accessible & is unambiguous
        if (TYPEIDS_EQ(pBase->pTypeDescriptor, pTargetTypeID) &&
            !(BCD_ATTRIBUTES(*pBase) & BCD_NOTVISIBLE) &&
            !(BCD_ATTRIBUTES(*pBase) & BCD_AMBIGUOUS)) {
            return pBase;
        }
    }
 
    return NULL;
}
 
static _RTTIBaseClassDescriptor * __cdecl FindVITargetTypeInstance (
                                PVOID pCompleteObject,                          // pointer to complete object
                                _RTTICompleteObjectLocator *pCOLocator, // pointer to Locator of complete object
                                TypeDescriptor *pSrcTypeID,        // pointer to TypeDescriptor of source object
                                int SrcOffset,                                          // offset of source object in complete object
                                TypeDescriptor *pTargetTypeID)     // pointer to TypeDescriptor of result of cast
{
    _RTTIBaseClassDescriptor *pBase, *pSubBase;
    _RTTIBaseClassDescriptor * const *pBasePtr, * const *pSubBasePtr;
    _RTTIBaseClassDescriptor *pResult = NULL;
    DWORD i, j;
 
                                // First, try down-casts
    for (i = 0, pBasePtr = pCOLocator->pClassDescriptor->pBaseClassArray->arrayOfBaseClassDescriptors;
         i < pCOLocator->pClassDescriptor->numBaseClasses;
         i++, pBasePtr++) {
        
        pBase = *pBasePtr;
                                // Test type of selected base class
        if (TYPEIDS_EQ(pBase->pTypeDescriptor, pTargetTypeID)) {
                                // If base class is proper type, see if it contains our instance of source class
            for (j = 0, pSubBasePtr = pBasePtr+1;
                 j < pBase->numContainedBases;
                 j++, pSubBasePtr++) {
 
                pSubBase = *pSubBasePtr;
                if (TYPEIDS_EQ(pSubBase->pTypeDescriptor, pSrcTypeID) &&
                    (PMDtoOffset(pCompleteObject, pSubBase->where) == SrcOffset)) {
                                // Yes, this is the proper instance of source class - make sure it is unambiguous
                                // Ambiguity now determined by inequality of offsets of source class within complete object, not pointer inequality
                    if ((pResult != NULL) && (PMDtoOffset(pCompleteObject, pResult->where) != PMDtoOffset(pCompleteObject, pBase->where))) {
                                // We already found an earlier instance, hence ambiguity
                        return NULL;
                    }
                    else {
                                // Unambiguous
                        pResult = pBase;
                    }
                }
            }
        }
    }
 
    if (pResult != NULL)
        return pResult;
 
                                // Down-cast failed, try cross-cast
    for (i = 0, pBasePtr = pCOLocator->pClassDescriptor->pBaseClassArray->arrayOfBaseClassDescriptors;
         i < pCOLocator->pClassDescriptor->numBaseClasses;
         i++, pBasePtr++) {
 
        pBase = *pBasePtr;
                                // Check if base class has proper type, is accessible & is unambiguous
        if (TYPEIDS_EQ(pBase->pTypeDescriptor, pTargetTypeID) &&
            !(BCD_ATTRIBUTES(*pBase) & BCD_NOTVISIBLE) &&
            !(BCD_ATTRIBUTES(*pBase) & BCD_AMBIGUOUS)) {
            return pBase;
 
        }
    }
 
    return NULL;
}
 
static ptrdiff_t __cdecl PMDtoOffset(
                                PVOID pThis,                    // ptr to complete object
                                const PMD& pmd)                 // pointer-to-member-data structure
{
    ptrdiff_t RetOff = 0;
 
    if (pmd.pdisp >= 0) {                       // if base is in the virtual part of class
        RetOff = pmd.pdisp;
        RetOff += *(ptrdiff_t*)((char*)*(ptrdiff_t*)((char*)pThis + RetOff) + pmd.vdisp);
    }
 
    RetOff += pmd.mdisp;
 
    return RetOff;
}

 

1 单继承

// WinDemo.cpp : 定义控制台应用程序的入口点。
//
#include <iostream>
#include "rtti.h"
using namespace std;

class A
{
public:
  virtual void func()
  {
    cout << "A::func()" << endl;
  }
};

class B 
{
public:
  virtual void func()
  {
    cout << "B::func()" << endl;
  }
};

class C : public A
{
public:
  virtual void func()
  {
    cout << "C::func()" << endl;
  }
private:
  int _val;
};


int main(int argc, char* argv[])
{
  A* pa = new C;  
  TypeDescriptor* ptypeA = &typeid(A);
  TypeDescriptor* ptypeC = &typeid(C);
  C* pc = (C*)__RTDynamicCastMY(pa, 0, (LPVOID)ptypeA, (LPVOID)ptypeC, FALSE);
  cout << pc << endl;
  return 0;
}

类C继承类A,内存布局：

 下断点：

extern "C" PVOID __cdecl __RTDynamicCastMY (
                                        PVOID inptr,         // Pointer to polymorphic object
                                        LONG VfDelta,       // Offset of vfptr in object
                                        PVOID SrcType,      // Static type of object pointed to by inptr
                                        PVOID TargetType,   // Desired result of cast
                                        BOOL isReference)   // TRUE if input is reference, FALSE if input is ptr
{
    PVOID pResult;
    _RTTIBaseClassDescriptor *pBaseClass;
 
    if (inptr == NULL)
        return NULL;
 
    __try {
        PVOID pCompleteObject = FindCompleteObject((PVOID *)inptr);//从基类指针的内存地址根据offset找到类的起始位置；
        _RTTICompleteObjectLocator *pCompleteLocator = (_RTTICompleteObjectLocator *) ((*((void***)inptr))[-1]);//找到类C的虚函数表中rtti信息，存储在[-1]中
 
        // Adjust by vfptr displacement, if any
        inptr = (PVOID *) ((char *)inptr - VfDelta);
        // Calculate offset of source object in complete object
        int inptr_delta = (char *)inptr - (char *)pCompleteObject;//计算基类和类C的地址偏移
 
        if (!(CHD_ATTRIBUTES(*COL_PCHD(*pCompleteLocator)) & CHD_MULTINH)) {             // if not multiple inheritance  单继承情况
            pBaseClass = FindSITargetTypeInstance(pCompleteObject,
                                                  pCompleteLocator,
                                                  (TypeDescriptor *) SrcType,
                                                  inptr_delta,
                                                  (TypeDescriptor *) TargetType);
        } 
......
    __except (GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION ? EXCEPTION_EXECUTE_HANDLER: EXCEPTION_CONTINUE_SEARCH) {
        pResult = NULL;
       // throw std::__non_rtti_object ("Access violation - no RTTI data!");
    }
 
    return pResult;
        
}

 其中：

(_RTTICompleteObjectLocator *)((*((void***)inptr))[-1])是取出虚表中的前一项，，虚表的前一项是RTTI的信息，这个结构的具体信息：

_RTTICompleteObjectLocator

这个是整个RTTI的结构定义，具体结构如下：

typedef const struct	_s_RTTICompleteObjectLocator	{
	DWORD							signature;
	DWORD							offset;
	DWORD							cdOffset;
	TypeDescriptor					*pTypeDescriptor;
	_RTTIClassHierarchyDescriptor	*pClassDescriptor;
	} _RTTICompleteObjectLocator;

其中：

  1. signature ： RTTI的签名。
  2. offset : 相对于对象开始的偏移量.
  3. cdOffset : 暂时不知道什么意思。
  4. pTypeDescriptor : 类的type_info结构。
  5. pClassDescriptor : 基类的描述信息。

TypeDescriptor

TypeDescriptor 即 type_info ，type_info 中有一个成员变量：

 mutable __std_type_info_data _Data;

其中_DecoratedName记录了当前类的名称

typedef const type_info TypeDescriptor;
class type_info
{
public:

    type_info(const type_info&) = delete;
    type_info& operator=(const type_info&) = delete;

    size_t hash_code() const noexcept
    {
        return __std_type_info_hash(&_Data);
    }

    bool operator==(const type_info& _Other) const noexcept
    {
        return __std_type_info_compare(&_Data, &_Other._Data) == 0;
    }

    bool operator!=(const type_info& _Other) const noexcept
    {
        return __std_type_info_compare(&_Data, &_Other._Data) != 0;
    }

    bool before(const type_info& _Other) const noexcept
    {
        return __std_type_info_compare(&_Data, &_Other._Data) < 0;
    }

    const char* name() const noexcept
    {
        #ifdef _M_CEE_PURE
        return __std_type_info_name(&_Data, static_cast<__type_info_node*>(__type_info_root_node.ToPointer()));
        #else
        return __std_type_info_name(&_Data, &__type_info_root_node);
        #endif
    }

    const char* raw_name() const noexcept
    {
        return _Data._DecoratedName;
    }

    virtual ~type_info() noexcept;

private:

    mutable __std_type_info_data _Data;
};


struct __std_type_info_data
{
    const char * _UndecoratedName;
    const char   _DecoratedName[1];
    __std_type_info_data() = delete;
    __std_type_info_data(const __std_type_info_data&) = delete;
    __std_type_info_data(__std_type_info_data&&) = delete;

    __std_type_info_data& operator=(const __std_type_info_data&) = delete;
    __std_type_info_data& operator=(__std_type_info_data&&) = delete;
};

_RTTIClassHierarchyDescriptor

typedef const struct	_s_RTTIClassHierarchyDescriptor {
	DWORD							signature;
	DWORD							attributes;
	DWORD							numBaseClasses;
	_RTTIBaseClassArray				*pBaseClassArray;
} _RTTIClassHierarchyDescriptor;

#define CHD_MULTINH					0x00000001
#define CHD_VIRTINH					0x00000002
#define CHD_AMBIGUOUS				0x00000004

其中 attributes的定义为CHD_xxxx分别如下：
CHD_MULTINH=0x00000001 : 表示多继承。
CHD_VIRTINH=0x00000002 : 存在虚拟继承。
CHD_AMBIGUOUS=0x00000004 : 继承情况模糊不清。
numBaseClasses : 表示基类的个数。
pBaseClassArray : 基类的描述数组。

_RTTIBaseClassArray

这个结构是基类数组描述，结构定义如下：其中存储了一个的基类，其中包括自己

typedef const struct	_s_RTTIBaseClassArray {
	_RTTIBaseClassDescriptor		*arrayOfBaseClassDescriptors[];
} _RTTIBaseClassArray;

typedef const struct	_s_RTTIBaseClassDescriptor {
	TypeDescriptor					*pTypeDescriptor;
	DWORD							numContainedBases;
	PMD								where;
	DWORD							attributes;
} _RTTIBaseClassDescriptor;

typedef struct PMD
{
	ptrdiff_t	mdisp;		// Offset of intended data within base
	ptrdiff_t	pdisp;		// Displacement to virtual base pointer
	ptrdiff_t	vdisp;		// Index within vbTable to offset of base
} PMD;

#define BCD_NOTVISIBLE				0x00000001
#define BCD_AMBIGUOUS				0x00000002
#define BCD_PRIVORPROTINCOMPOBJ		0x00000004
#define BCD_PRIVORPROTBASE			0x00000008
#define BCD_VBOFCONTOBJ				0x00000010
#define BCD_NONPOLYMORPHIC			0x00000020

 

如：

（1） C单继承A,因此offset为0；

（2）_DecoratedName中可以看出类C存储的名称为：0x001bd154 ".?AVC@@"

（3）从pBaseClassArray中，可以看出类C有两个基类，分别是C，A 为什么要记录C呢，这个东西在dynastic_cast中有用

计算单继承中 down_cast:

static _RTTIBaseClassDescriptor * __cdecl FindSITargetTypeInstance (
                                PVOID pCompleteObject,                          // pointer to complete object
                                _RTTICompleteObjectLocator *pCOLocator, // pointer to Locator of complete object
                                TypeDescriptor *pSrcTypeID,        // pointer to TypeDescriptor of source object
                                int SrcOffset,                                          // offset of source object in complete object
                                TypeDescriptor *pTargetTypeID)     // pointer to TypeDescriptor of result of cast
{
    _RTTIBaseClassDescriptor *pBase;
    _RTTIBaseClassDescriptor * const *pBasePtr;
    DWORD i;
    //从基类的数组中查找是否存在匹配的基类，如果存在则返回
    for (i = 0, pBasePtr = pCOLocator->pClassDescriptor->pBaseClassArray->arrayOfBaseClassDescriptors;
         i < pCOLocator->pClassDescriptor->numBaseClasses;
         i++, pBasePtr++) {
 
        // Test type of selected base class
        pBase = *pBasePtr;
        if (TYPEIDS_EQ(pBase->pTypeDescriptor, pTargetTypeID) &&
            !(BCD_ATTRIBUTES(*pBase) & BCD_NOTVISIBLE)) {
            return pBase;
        }
    }
    return NULL;
}

2 多继承

// WinDemo.cpp : 定义控制台应用程序的入口点。
//
#include <iostream>
#include "rtti.h"
using namespace std;

class A
{
public:
  virtual void func()
  {
    cout << "A::func()" << endl;
  }
};

class B 
{
public:
  virtual void func()
  {
    cout << "B::func()" << endl;
  }
};

class C : public B,public A
{
public:
  virtual void func()
  {
    cout << "C::func()" << endl;
  }
private:
  int _val;
};


int main(int argc, char* argv[])
{
  A* pa = new C;  
  TypeDescriptor* ptypeA = &typeid(A);
  TypeDescriptor* ptypeC = &typeid(C);
  C* pc = (C*)__RTDynamicCastMY(pa, 0, (LPVOID)ptypeA, (LPVOID)ptypeC, FALSE);
  cout << pc << endl;
  return 0;
}

其中，特意让C先继承B,这样当  A* pa = new C; 时 A类的虚函数指针在类C中的内存中有偏移，如下：

 

在FindCompleteObject 中，

 会根据基类A类型的指针，通过虚表中_RTTICompleteObjectLocator记录的offset找到类C的开始地址

 

static PVOID __cdecl FindCompleteObject (PVOID *inptr)          // Pointer to polymorphic object
{
    // Ptr to CompleteObjectLocator should be stored at vfptr[-1]
    _RTTICompleteObjectLocator *pCompleteLocator = (_RTTICompleteObjectLocator *) ((*((void***)inptr))[-1]);
    char *pCompleteObject = (char *)inptr - pCompleteLocator->offset;
    // Adjust by construction displacement, if any
    if (pCompleteLocator->cdOffset)
        pCompleteObject += *(ptrdiff_t *)((char *)inptr - pCompleteLocator->cdOffset);
    return (PVOID) pCompleteObject;
}

即   char *pCompleteObject = (char *)inptr - pCompleteLocator->offset;找到类C的内存开始地址

多继承下dynastic_cast转换：

 

static _RTTIBaseClassDescriptor * __cdecl FindMITargetTypeInstance (
                                PVOID pCompleteObject,                          // pointer to complete object
                                _RTTICompleteObjectLocator *pCOLocator, // pointer to Locator of complete object
                                TypeDescriptor *pSrcTypeID,        // pointer to TypeDescriptor of source object
                                int SrcOffset,                                          // offset of source object in complete object
                                TypeDescriptor *pTargetTypeID)     // pointer to TypeDescriptor of result of cast
{
    _RTTIBaseClassDescriptor *pBase, *pSubBase;
    _RTTIBaseClassDescriptor * const *pBasePtr, * const *pSubBasePtr;
    DWORD i, j;
 
                                // First, try down-casts 首先找到目标类C
    for (i = 0, pBasePtr = pCOLocator->pClassDescriptor->pBaseClassArray->arrayOfBaseClassDescriptors;
         i < pCOLocator->pClassDescriptor->numBaseClasses;
         i++, pBasePtr++) {
        
        pBase = *pBasePtr;
                                // Test type of selected base class
        if (TYPEIDS_EQ(pBase->pTypeDescriptor, pTargetTypeID)) {
                                // If base class is proper type, see if it contains our instance of source class
            //如果找到目标类C,继续找看是否能找到目标类A,以证明存在合法的继承关系
            for (j = 0, pSubBasePtr = pBasePtr+1;
                 j < pBase->numContainedBases;
                 j++, pSubBasePtr++) {
 
                pSubBase = *pSubBasePtr;
                if (TYPEIDS_EQ(pSubBase->pTypeDescriptor, pSrcTypeID) &&
                    (PMDtoOffset(pCompleteObject, pSubBase->where) == SrcOffset)) {
                                // Yes, this is the proper instance of source class
                    return pBase;//找到，返回类C的内存起始地址
                }
            }
        }
    }
 
                                // Down-cast failed, try cross-cast
    for (i = 0, pBasePtr = pCOLocator->pClassDescriptor->pBaseClassArray->arrayOfBaseClassDescriptors;
         i < pCOLocator->pClassDescriptor->numBaseClasses;
         i++, pBasePtr++) {
 
        pBase = *pBasePtr;
                                // Check if base class has proper type, is accessible & is unambiguous
        if (TYPEIDS_EQ(pBase->pTypeDescriptor, pTargetTypeID) &&
            !(BCD_ATTRIBUTES(*pBase) & BCD_NOTVISIBLE) &&
            !(BCD_ATTRIBUTES(*pBase) & BCD_AMBIGUOUS)) {
            return pBase;
        }
    }
 
    return NULL;
}

 用A* 指向派生类，offset为4；

_Data中 时：?AVC@@ 即类C;

attributes:1 表示多继承

pClassDescriptor:中看到有三个基类C B A 其中A的mdisp=4，即在A类虚函数指针在内存布局中的偏移

参考：

C++ dynamic_cast实现原理_passion_wu128的专栏-CSDN博客_dynamic_cast原理

C++ RTTI 实现原理详解_xdesk的专栏-CSDN博客_c++ rtti



dynamic_cast, RTTI， 整理 - Dirichlet - 博客园

工程资源：https://download.csdn.net/download/LIJIWEI0611/31230142

~怎么回事啊~
关注
  • 1
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
聊聊dynamic_cast的原理和缺陷
SWX230162的博客
11-22 572
运行时类型检查意味着 dynamic_cast 在运行时会检查类型的合法性，如果转换合法，则返回转换后的类型；其次，由于 dynamic_cast 需要 RTTI（运行时类型信息）的支持，如果禁用了 RTTI，dynamic_cast 也就不能使用了。要使用 dynamic_cast，父类必须要有虚函数，有了虚函数就会生成虚表，才能分辨我们的父类指针指向的是父类还是子类。这也是 dynamic_cast 的一个限制，只有当类中至少有一个虚函数时，这个类的类型才可以被 dynamic_cast 进行转换。
C++运行阶段类型识别（Runtime Type Identification）（C++新特性）
DayDayUp
12-30 1711
编译时开销 编译器在编译代码时，主要进行：词法分析（识别单词，确认词类：标识符、关键字、字符串、数字等等）、语法分析（识别短语和句型的语法属性，生成语法树）、语义分析（确认单词，句型的语义特征，如加减乘除等）、代码优化和代码生成等。模板、类层次结构、强制类型检查等新特性，以及大量使用了这些新特性的STL标准库都增加了编译器负担。 运行时开销 C++中有可能引入额外运行时开销的新特性包括： 虚基类 虚函数 RTTI（dynamic_cast和typeid） 异常 对象的构造和析构 RTTI
详解dynamic_cast
最新发布
简介
05-10 467
是C++中一个重要的类型转换运算符，主要用于在运行时进行安全的类型转换，特别是在涉及多态的类层次结构中。它是C++面向对象编程中的一个重要特性，提供了一种检查和转换基类指针或引用到派生类的方式。
浅议 Dynamic_cast 和 RTTI
u011764940的博客
04-05 451
浅议 Dynamic_cast 和 RTTI 写这篇博文的目的是，记录学习过程。 对于问题要较真，在解决这个问题中会学到很多，远远超过自己期望，锻炼思维，享受这个过程。 问题： Static_cast 与 Dynamic_cast的区别 来自书本上的解释： 用 static_cast<type-id > ( expression ) 1. static_cast(e...
dynamic_cast详解
热门推荐
不亦快斋
03-22 5万+
作为四个内部类型转换操作符之一的dynamic_cast和传统的C风格的强制类型转换有着巨大的差别。除了dynamic_cast以外的转换，其行为的都是在编译期就得以确定的，转换是否成功，并不依赖被转换的对象。而dynamic_cast则不然。在这里，不再讨论其他三种转换和C风格的转换。首先，dynamic_cast依赖于RTTI信息，其次，在转换时，dynamic_cast会检查转换的sourc
C++ libcxxabi中dynamic_cast 实现
梦的灰色边沿...
11-26 407
C++中，用于有虚函数的继承链中父类型到子类型的安全转换。class A{public:class B{如何识别当前类的类型，这依赖于RTTI。C++中包含虚函数的对象都有一个虚函数表，一般情况下都在首地址（多继承和虚继承会有多个）有一个指向该虚函数表的虚函数表指针。基类偏移；typeinfo；如果有虚函数的话会有虚析构函数指针，一般情况下有两个；虚函数指针，如果是虚继承对应的虚函数指针可能是一个thunk function。
cast函数_C++ GCC 对象模型 dynamic_cast实现 (Part 2)
weixin_39849888的博客
11-25 167
dynamic_cast实现dynamic_cast是C++语言的一部分，并不是STL dynamic_cast is built in to the language. It does require an implementation, but there is no standardised location for the http://implementation.In the gcc ...
解析C++编程中的bad_cast异常
09-02
在C++中，只有含有虚函数的类才能支持`dynamic_cast`，因为虚函数是实现多态的基础。当尝试将一个指向基类的指针或引用转换为派生类的指针或引用时，如果该基类对象实际上不是派生类的对象，`dynamic_cast`就会返回`...
dynamic-create-control-array.rar_C++builder
09-24
TButton* Button = dynamic_cast*>(Sender); int Index = ArrayIndexOf(ButtonArray, Button, 0, 10); // Now you can access the index of the button that was clicked // and perform actions accordingly. }...
VC简单实现动态连接库.rar_动态连接库
09-20
动态连接库（Dynamic Link Library，DLL）是Windows操作系统中一种重要的共享代码机制，它允许多个应用程序共享同一块代码，从而节省内存并简化软件更新。在本案例中，我们看到一个关于使用VC++（Visual C++）创建...
RTTI.02.rar_visual c
09-23
《深入理解MFC的RTTI：Visual C++实践解析》 在C++编程中，运行时类型信息（Run-...通过学习和理解这个模拟实现，开发者不仅可以掌握MFC中RTTI的基本原理，还能更好地运用到实际项目中，提高代码的灵活性和可维护性。
c++设计与演化_原理经典资料
12-20
6. **运行时类型信息（RTTI）**：C++提供了运行时检查对象类型的机制，如`dynamic_cast`和`typeid`，这在多态编程中非常有用。 7. **C++与C的兼容性**：C++语言在设计时考虑到了与C语言的兼容性，允许开发者直接...
C++ 中 dynamic_cast 浅析
塞北狼烟
08-17 428
摘要】 dynamic_cast 操作符，将基类的指针或引用安全的转换为派生类的指针或引用。主要讲解，dynamic_cast操作符的原理、使用方式、编译器设置、返回值等相关知识。 【正文】 dynamic_cast 操作符，将基类的指针或引用安全的转换为派生类的指针或引用。 1. 原理 将一个基类对象指针（或引用）cast （抛）到继承类指针，dynamic_cas
dynamic_cast彻底明白了~
互联网
03-13 3957
dynamic_cast &lt; type-id &gt; ( expression) 该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void*； 如果type-id是类指针类型，那么expression也必须是一个指针，如果type-id是一个引用，那么expression也必须是一个引用。 dynamic_cast运算符可以在执...
dynamic_cast
寂蝶难双，窃窃思羽.
04-08 1488
运行时类型识别(run-time type identification,RTTI)的功能由俩个运算符实现： 1.typeid运算符，用于返回表达式的类型 2.dynamic_cast运算符，用于将父类的指针或引用安全地转换成子类的指针或引用 当我们将这俩个运算符用于某种类型的指针或引用，并且该类型含有虚函数时，运算符将使用指针或引用所绑定对象的动态类型 适用情况：我们想使用父类对象的指针或应...
dynamic_cast与一般的强制转换
Jerish的博客
04-04 1万+
接触过C语言的同学可能很喜欢使用C风格的强制转换（也就是一般形式的强转）。 （类型）变量 用起来很方便，可以显式的把某些类型转换成我们想要的类型，比如（int*）字符。这样的使用对常见的内置类型可谓是屡试不爽，但是对于C++中的对象用起来却是危机四伏。所以dynamic_cast应运而生。 我们很容易查到dynamic_cast 的定义是将一个基类对象指针（或引用）cast到继承类指针，dy
理解C++ dynamic_cast
重文-技艺山海经
02-17 364
理解C++ dynamic_cast 在面向对象程序设计中，有时我们需要在运行时查询一个对象是否能作为某种多态类型使用。与Java的instanceof，以及C#的as、is运算符类似，C++提供了dynamic_cast函数用于动态转型。相比C风格的强制类型转换和C++ reinterpret_cast，dynamic_cast提供了类型安全检查，是一种基于能力查询(Cap
使用dynamic_cast强制将基类指针转换成子类指针
小码农的csdn博客
04-11 4597
在继承关系中，如果需要增加新的接口，又不想在父类中添加虚函数，这时可以在子类中增加新的接口，当使用父类指针访问这个函数的时候，需要用dynamic_cast进行类型强转，因为父类中本身并没有这个函数，所以要实现最终的调用，就需要对指针的实际指向进行类型判断(RTTI) 这种调用函数方式有点类似于多态，但并非是真正的多态，因为它是硬性的将基类指针转换成子类的指针达到访问派生类方法的目的，所以实
dynamic_cast的底层原理
08-22
dynamic_cast实现原理的底层机制可以根据引用和引用来解释。dynamic_cast用于将指向多态类型（包含虚函数）的指针或引用进行downcast或crosscast。它会在运行时进行类型检查来确定是否可以进行转换。 在实现上，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值