C++ dynamic_cast实现原理

最新推荐文章于 2023-11-22 20:55:42 发布
最新推荐文章于 2023-11-22 20:55:42 发布
阅读量2.2w 收藏 47
点赞数 11
文章标签： dynamic_cast 原理
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/passion_wu128/article/details/38511957
版权

dynamic_cast是一个操作符，其用法不再赘述。查看汇编码可以发现实际调用的是这个函数__RTDynamicCast，其内部实现如下：

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 __RTDynamicCast (PVOID, LONG, PVOID, PVOID, BOOL);

extern "C" PVOID __cdecl __RTtypeid (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 __RTtypeid (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 __RTDynamicCast (
                                        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;
}

测试代码： 

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

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

class B : public A
{
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*)__RTDynamicCast(pa, 0, (LPVOID)ptypeA, (LPVOID)ptypeC, FALSE);
	cout << pc << endl;

	return 0;
}

从以上代码可以看出：只能在有虚函数的类层次之间使用dynamic_cast。要实现dynamic_cast，编译器会在每个含有虚函数的类的虚函数表的前四个字节存放一个指向_RTTICompleteObjectLocator结构的指针，当然还要额外空间存放_RTTICompleteObjectLocator及其相关结构的数据。以上面代码的类C来说：


这个_RTTICompleteObjectLocator就是实现dynamic_cast的关键结构。里面存放了vfptr相对this指针的偏移，构造函数偏移（针对虚拟继承），type_info指针，以及类层次结构中其它类的相关信息。如果是多重继承，这些信息更加复杂。

所以，dynamic_cast的时间和空间代价是相对较高的，在设计时应避免使用。

如果整个工程都不需要dynamic_cast，可以禁用运行时类型信息（vs2008默认是启用的），这样编译器就不会产生_RTTICompleteObjectLocator及相关数据。

禁用方法如下：

依次选择【工程属性】、【配置属性】、【C/C++】、【语言】。将【启用运行时类型信息】改为”否“。


                

        

        

    




    

      

        

            

              
                
                  passion_wu128
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    11
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    47
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                  4
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
PHP has encountered an Access Violation at XXXXXX  的解决方法

				
			

			

				

					09-11
				

			

		

		

			
				
PHP has encountered an Access Violation at XXXXXX 很多人说，是php版本的问题,更新到高点的PHP能解决,你可以试试,如果还不行

			
		

	



                

              
                



	

		

			

				
					
C++基础#20：C++中的动态强制dynamic_cast

				
			

			

				

					记录和分享程序人生的点点滴滴
				

				

					01-06
					
					1万+
					
				

			

		

		

			
				
C++中提供了动态强制（dynamic_cast），是一种运行时类型识别机制，可以从一个虚的基类强制到一个派生类。我们常常需要知道，在运行过程中，我们真正在使用的是哪个类的对象，这时，可以明确地使用dynamic_cast来得到运行时类型的信息。

			
		

	



                


  
              

                


	

		

			

				
					
[C++] - dynamic_cast介绍及工作原理、typeid、type_info

				
			

			

				

					浮生的博客
				

				

					05-20
					
					9351
					
				

			

		

		

			
				
Table of Contents



1.dynamic_cast工作原理：

2.dynamic_cast介绍：

3.static_cast与dynamic_cast:

4.typeid:

1.dynamic_cast工作原理

《深度探索C++对象模型》中有个例子：


class Point
{
public:
	Point(float xval);
	virtual ~Point();

	float x() const;
	static int PointCount();

prote.

			
		

	





	

		

			

				
					
C++中的类型转换static_cast、dynamic_cast、const_cast和reinterpret_cast总结

				
			

			

				

					09-04
				

			

		

		

			
				
主要介绍了C++中的类型转换static_cast、dynamic_cast、const_cast和reinterpret_cast总结,需要的朋友可以参考下

			
		

	



		

			
		



	

		

			

				
					
C++ 中dynamic_cast的用法

				
			

			

				

					01-20
				

			

		

		

			
				
/*这是从网上摘下的样例，主要讲述了 dynamic_cast<> 的用法。*/
	/*
	作用：将一个基类对象指针（或引用）cast到继承类指针，dynamic_cast会依据基类指针是否真正指向继承类指针来做对应处理，
	即会作一定的推断。
	对指针进行dynamic_cast，失败返回null，成功返回正常cast后的对象指针；
	对引用进行dynamic_cast，失败抛出一个异常，成功返回正常cast后的对象引用。
	注意：dynamic_cast在将父类cast到子类时，父类必需要有虚函数。比如在以下的代码中将CBasic类中的test函数不定义成
	virtual时，编译器会报错

			
		

	





	

		

			

				
					
dynamic_cast_benchmark:C ++中dynamic_cast的三种不同实现的性能比较

				
			

			

				

					03-29
				

			

		

		

			
				
dynamic_cast_benchmark
 三种不同的dynamic_cast实现的性能比较
请参阅我的博客文章：
 汇编： 
git submodule init
git submodule update
make
./dynamic_cast_benchmark
 目标编译器：clang版本13.0.0
 以下是dynamic_cast_benchmark生成的输出。
类层次：深层
演员类型：仅成功（从H类播出）
 基准：static_cast
  -: 283 MHz (100%) [2000000] |---------------------------------------------------------------|
实现：dynamic_cast
  A: 279 MHz ( 99%) [2000000] |----------------------------

			
		

	





	

		

			

				
					
dynamic_cast使用以及原理探究

				
			

			

				

					Ray_H5的博客
				

				

					09-27
					
					1497
					
				

			

		

		

			
				
关键就是虚函数表，因为B类有自己的虚函数表，A类也有自己的虚函数表，根据虚函数表的不同可以判断到底是属于哪个类。

			
		

	





	

		

			

				
					
c++内存布局、typeid、RTTI、dynamic_cast原理、虚函数调用原理串联一下

				
			

			

				

					why_are_you_so的博客
				

				

					03-18
					
					550
					
				

			

		

		

			
				
c++内存布局、typeid、RTTI、dynamic_cast原理、虚函数调用原理串联一下

			
		

	





	

		

			

				
					
聊聊dynamic_cast的原理和缺陷

					
最新发布

				
			

			

				

					SWX230162的博客
				

				

					11-22
					
					366
					
				

			

		

		

			
				
运行时类型检查意味着 dynamic_cast 在运行时会检查类型的合法性，如果转换合法，则返回转换后的类型；其次，由于 dynamic_cast 需要 RTTI（运行时类型信息）的支持，如果禁用了 RTTI，dynamic_cast 也就不能使用了。要使用 dynamic_cast，父类必须要有虚函数，有了虚函数就会生成虚表，才能分辨我们的父类指针指向的是父类还是子类。这也是 dynamic_cast 的一个限制，只有当类中至少有一个虚函数时，这个类的类型才可以被 dynamic_cast 进行转换。

			
		

	





	

		

			

				
					
dynamic_cast实现原理

				
			

			

				

					LIJIWEI0611的博客
				

				

					10-11
					
					2357
					
				

			

		

		

			
				
在使用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修改为___...

			
		

	





	

		

			

				
					
c++ dynamic_cast与static_cast使用方法示例

				
			

			

				

					09-04
				

			

		

		

			
				
本文用示例讲解了dynamic_cast、static_cast子类与基类之间转换功能的使用方法

			
		

	





	

		

			

				
					
【C++ 多态 】深入理解C++的运行时类型信息（RTTI）：dynamic_cast和typeid的应用与原理

				
			

			

				

					探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
				

				

					07-04
					
					215
					
				

			

		

		

			
				
在C++中，运行时类型信息（Runtime Type Information，简称RTTI）是一种强大的机制，它允许在程序运行时查询和操作对象的类型信息。RTTI的主要组成部分是`dynamic_cast`和`typeid`，它们分别用于安全的类型转换和类型识别。


			
		

	





	

		

			

				
					
华为工程师，带你实战C++视频精讲

				
			

			

				

					05-06
				

			

		

		

			
				
这是一套全面而系统的C++学习：1、C++对C的全面提高(类型增强，函数重载，默认参数，引用,new/delete内联函数，类型强转，命名空间，系统string类；2、封装，类与对象，友元，运算符重载；3、继承与派生，多态，UML，设计模式；5、文件IO流，模板，STL，,异常机制。

			
		

	





	

		

			

				
					
[C/C++ 基础](类型转换系列三) dynamic_cast与std::dynamic_pointer_castcast

				
			

			

				

					qq_28127741的博客
				

				

					10-09
					
					4363
					
				

			

		

		

			
				
文章目录结论事例dynamic_cast原理使用测试std::dynamic_pointer_cast原理使用测试强调
如果说static_cast是C++对C风格类型转换的继承，那么dynaic_cast可以说是完全脱离了C风格的类型转换，主要服务于C++的多态特性。学会正确的使用这种类型转换在大型软件开发的实践中可以说是非常的重要。
在大型软件中多态特性往往会被用到极致，dynamic_cast的使用可以帮助我们在开发过程中规避很多风险。
结论
dynamic_cast<new_type>(

			
		

	





	

		

			

				
					
cast函数_C++ GCC 对象模型 dynamic_cast实现 (Part 2)

				
			

			

				

					weixin_39849888的博客
				

				

					11-25
					
					162
					
				

			

		

		

			
				
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 ...

			
		

	





	

		

			

				
					
dynamic_cast用法总结

					
热门推荐

				
			

			

				

					weixin_44212574的博客
				

				

					04-05
					
					3万+
					
				

			

		

		

			
				
dynamic_cast < type-id > ( expression)
该运算符把expression转换成type-id类型的对象。Type-id必须是类的指针、类的引用或者void*；
如果type-id是类指针类型，那么expression也必须是一个指针，如果type-id是一个引用，那么expression也必须是一个引用。

...

			
		

	





	

		

			

				
					
C++：dynamic_cast

				
			

			

				

					风静如云的博客
				

				

					06-09
					
					4757
					
				

			

		

		

			
				
dynamic_cast主要用于有继承关系的多态类（基类必须有虚函数）的指针或引用之间的转换。1.通过dynamic_cast，将派生类指针转换为基类指针（上行转换），这个操作与static_cast的效果是一样的。2.通过dynamic_cast，将基类指针转换为派生类指针（下行转换），dynamic_cast具有类型检查的功能，比static_cast更安全（如果转换的是指针，失败时会返回空指针；如果转换的是引用，会抛出std::bad_cast异常）...

			
		

	





	

		

			

				
					
C++ 关于 dynamic_cast 运算符

				
			

			

				

					qq_42303573的博客
				

				

					11-15
					
					1058
					
				

			

		

		

			
				
C++ 关于 dynamic_cast 运算符

			
		

	





	

		

			

				
					
dynamic_cast的使用小结

				
			

			

				

					ybg的博客
				

				

					06-30
					
					144
					
				

			

		

		

			
				
https://blog.csdn.net/u012411498/article/details/80804755
//dynamic_cast 上下行转换都需要虚函数

#include <iostream>
using namespace std;
class B
{
        public:
                B(){}
                virtual void foo(){};
                //void foo(){};//必须要是

			
		

	





	

		

			

				
					
c++dynamic_cast

				
			

			

				

					08-31
				

			

		

		

			
				
C++中的dynamic_cast是一种在运行时进行类型转换的机制，它可以用来将一个指向基类对象的指针或引用转换为指向派生类对象的指针或引用。在dynamic_cast被设计之前，C++无法直接进行虚基类到派生类的强制转换。通过使用dynamic_cast，我们可以在运行时获取到对象的实际类型信息，并进行相应的转换操作。

需要注意的是，向上转换（将派生类指针赋值给基类指针）无论是否使用dynamic_cast，C++都能正确识别。这是因为向上转换是安全的，派生类的对象可以被看作是基类的对象。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
-  *1* *2* *3* [C++基础#20：C++中的动态强制dynamic_cast](https://blog.csdn.net/liranke/article/details/5145787)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"]
[ .reference_list ]

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		
评论 4

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值