static_cast和dynamic_cast

最新推荐文章于 2024-01-15 15:00:20 发布
最新推荐文章于 2024-01-15 15:00:20 发布
阅读量281 收藏
点赞数
分类专栏： C/C++ 文章标签： C++编程实例 static_cast 类型 强转 强制转换 dynamic_cast
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/tanghong1996/article/details/107305951
版权
本文总结了C++中的static_cast和dynamic_cast两种类型转换方式。static_cast允许在有继承关系的对象间进行转换，但不安全，可能会导致NULL指针。dynamic_cast则需要多态性（至少一个虚函数），转换时会检查安全性，转换失败会返回NULL。下行转换时，从基类指针转换到子类指针必须确保实际类型匹配。
摘要由CSDN通过智能技术生成

static_cast和dynamic_cast总结

class A {}
class B {}

注意： 若继承 A为基类 B为派生类

代码class A { };









class B:public A { };		class A
{
public:
virtual void Test(){}
virtual ~A(){}
};
class B:public A
{ public:
//virtual void Test(){}
//virtual ~B(){}
};		class A
{ public:
virtual void Test(){}
virtual ~A(){}
};
class B:public A
{
public:
virtual void Test(){}
virtual ~B(){}
};
继承关系有继承关系 父无虚函数有继承关系 父有虚函数 子无有继承关系 父子有虚函数
static_cast//right 基类指针指向子类
pObjA = static_cast<A*>(pObjB);
//right强制转换 OK 基类到子类
pObjB = static_cast<B*>(pObjA);
均不为NULL

//转换为基类引用
objA = static_cast<A&>(objB);
objA = static_cast(objB);

//right 基类指针指向子类对象
pObjA = pObjB;
//right 基类指向子类
objA = objB;
//right 转换为基类引用
objB = static_cast<B&>(objA);







//error 基类不可转换为子类
//objB = static_cast(objA);
//error 子类指针指向父类对象
//pObjB = pObjA;
//error 无赋值操作符
//objB = objA;		//right 基类指针指向子类
pObjA = static_cast<A*>(pObjB);


//强制转换 OK 基类到子类
pObjB = static_cast<B*>(pObjA);
均不为NULL











//强制转换 OK 基类到子类
pObjA = &objB;
pObjB = static_cast<B*>(pObjA);
if (pObjB)
{
cout << “B Succ” << endl;
}
else
{
cout << “B NULL” << endl;
}		//right 基类指针指向子类
pObjA = static_cast<A*>(pObjB);


//强制转换 OK 基类到子类
pObjB = static_cast<B*>(pObjA);
均不为NULL











//强制转换 OK 基类到子类
pObjA = &objB;
pObjB = static_cast<B*>(pObjA);
if (pObjB)
{
cout << “B Succ” << endl;
}
else
{
cout << “B NULL” << endl;
}
dynamic_cast//right 基类指针指向子类
pObjA = dynamic_cast<A*>(pObjB);
且pObjA不为NULL








// ERROR 继承关系 父类无虚函无多态
pObjB = dynamic_cast<B*>(pObjA);		//right 基类指针指向子类
//上行一般没问题
pObjA = dynamic_cast<A*>(pObjB);

// warning 继承关系
pObjB = dynamic_cast<B*>(pObjA);
pObjB = NULL

//下行转换成功事例
pObjA = &objB;
pObjB = dynamic_cast<B*>(pObjA);
pObjB SUCCSESS		//right 基类指针指向子类
//上行一般没问题
pObjA = dynamic_cast<A*>(pObjB);

// warning 继承关系
pObjB = dynamic_cast<B*>(pObjA);
pObjB = NULL

//下行转换成功事例
pObjA = &objB;
pObjB = dynamic_cast<B*>(pObjA);
pObjB SUCCSESS

向上转换，即为子类指针指向父类指针（一般不会出问题）；A = dynamic_cast(B)


向下转换，即将父类指针转化子类指针。B = dynamic_cast(A) (不报错，编译通过，但是转换失败NULL)


向下转换的成功与否还与将要转换的类型有关，即要转换的指针指向的对象的实际类型与转换以后的对象类型一定要相同，否则转换失败。

代码class A
{
public:
virtual void Test(){}
virtual ~A(){}
};
class D
{
};		class A { };







class D { };
继承关系无继承关系 有多态无继承关系 无多态
static_cast// ERROR
pObjD = static_cast<D*>(pObjA);
// ERROR
pObjA = static_cast<A*>(pObjD);		// ERROR
pObjD = static_cast<D*>(pObjA);
// ERROR
pObjA = static_cast<A*>(pObjD);
dynamic_cast//warning
pObjD = dynamic_cast<D*>(pObjA);
cout << “D NULL” << endl;		// ERROR
pObjD = dynamic_cast<D*>(pObjA));

static_cast

  1. 有继承都 ok 但是 B=static_cast(A) 不安全
  2. 无继承 一般不 ok 若想成功

只可对象转换

class A
{
public:
	virtual void test(){}
	virtual ~A(){}
};
class D
{
	public:
	D(){}
	D(A& a){}
	//virtual ~D(){}
};

A objA;
D objD;
objD = static_cast<D>(objA);

如果让非继承关系通过编译，那么D类必须含有以A类的对象（或对象的引用）为参数的构造函数

dynamic_cast

  1. 编译 通过 必须有多态 有虚函数 可以没有继承 但存在 NULL
  2. 转换成功，必须多态，继承，

基类指向子类 ok （子类转换为基类 ok ） A = dynamic_cast(B)

子类指向基类 要 ok （基类转换为子类 ok ） B = dynamic_cast(A) 必须 基类引用或者指向子类 否则 NULL，成功实例如下

dynamic_cast 下行转换

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class Base{

public:
    Base() :str(nullptr){}
    Base(string s) :str(s){}
    virtual void print()
    {
        cout << str << "  ";
    }
private:
    string str;
};

class Derived:public Base

{
public:
    Derived(){}
    Derived(string s,int i) :Base(s),ival(i){}
    void print()
    {
        Base::print();
        cout << ival << endl;
    }
    void print_ival()
    {
        cout << "ival:" << ival << endl;
    }
private:
    int ival;
};


int main()
{
    Base base("aaa");
    Derived de("xxx", 111);
    //指针dynamic_cast
    Base* pb = &de;
    if (Derived* pd1 = dynamic_cast<Derived*>(pb))
    {
        pd1->print_ival();
    }
    else
    {
        //转换失败返回空指针
        cout << "type error..." << endl;
    }
    //引用dynamic_cast
    Base& rf = de;
    try
    {
        Derived& d = dynamic_cast<Derived&>(rf);
        d.print_ival();
    }
    catch (const std::bad_cast& ex)
    {
        //转换失败，抛出std::bad_cast异常
        cout << ex.what();
    }
    // system("pause");
}

完整测试代码

#include <iostream>
#include <string>
#include <vector>
using namespace std;

class A
{
public:
	virtual void foo(){}
};
class B
{
public:
	virtual void foo(){}
};

class C : public A, public B
{
public:
	virtual void foo(){}
};



class D {};
class E : public D {};
class F : public D {};
class G {};

void bar1(A *pa)
{
    if (B *pb = dynamic_cast<B *>(pa))//无继承关系 但是存在多态//为空
    {
        cout << "bar1 pb succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar1 pb error..." << endl;
    }
    B* pb=new B();
    if (A *pa1 = dynamic_cast<A *>(pb))//无继承关系 但是存在多态//为空
    {
        cout << "bar1 pa1 succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar1 pa1 error..." << endl;
    }
    delete pb;
    // B *pb = static_cast<B *>(pa);   //error A B不存在继承关系

    if (C *pc = static_cast<C *>(pa))
    {
        cout << "bar1 pc succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar1 pc error..." << endl;
    }

    //C *pc = static_cast<C *>(pa);   //ok
    // C *pc1 = static_cast<C *>(pb);  //ok
}
void bar1_2(A *pa,C *pc)
{
    if (A *pa1 = static_cast<A *>(pc))
    {
        cout << "bar1_2 pa1 succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar1_2 pa1 error..." << endl;
    }


    if (C *pc1 = static_cast<C *>(pa))//ok   //No   safe
    {
        cout << "bar1_2 pc1 succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar1_2 pc1 error..." << endl;
    }

    // C *pc1 = static_cast<C *>(pa);   //ok   //No   safe

    if (C *pc2 = dynamic_cast<C *>(pa))
    {
        cout << "bar1_2 pc2 succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar1_2 pc2 error..." << endl;
    }

    if (A *pa2 = dynamic_cast<A *>(pc))
    {
        cout << "bar1_2 pa2 succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar1_2 pa2 error..." << endl;
    }
    // A a;
    // B b;
    // b = static_cast<B>(a);
}

void bar2()
{
    C c;
    A *pa = &c;
    B *pc = static_cast<B *>(static_cast<C *>(pa));//A->C转换不安全 C->B安全

    if (pc)
    {
        cout << "bar2 pc succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar2 pc error..." << endl;
    }
}

void bar3(D* pD) {
    // E* pb1 = dynamic_cast<E*>(pD);   //error    //无多态类型//dynamic_cast不可转换

    E* pE = static_cast<E*>(pD);        //ok NOt safe    //基类指针指向子类
    if (pE)
    {
        cout << "bar3 pE succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar3 pE error..." << endl;
    }

    D* pd3= static_cast<D *>(pE);    //right    //基类指针指向子类
    if (pd3)
    {
        cout << "bar3 pd3 succ..." << endl;
    }
    else
    {
        //转换失败返回空指针
        cout << "bar3 pd3 error..." << endl;
    }
    E* pd4 = static_cast<E *>(pD);   //right    //强制转换 OK 基类指针到子类指针
                                                //但是不安全  若pd4调用E有而D没有的，则访问越界


    E* pE2;
    // F* pF = static_cast<F*>(pE2);    //error 继承于统一类的派生指针之间转换 
    // E* pF3 = static_cast<E*>(pF);    //error 继承于统一类的派生指针之间转换

    F* pF2;
    // G* pG = static_cast<G*>(pF2);    //error 两个无关联之间转换
}

void bar4()
{
    D objd;
    E obje;
    G objg;

    objd = static_cast<D&>(obje);     //转换为基类引用    
    objd = static_cast<D>(obje);        
    // obje = static_cast<E>(objd);      //error 不能进行转换 不能讲D赋值给E
    // objg = static_cast<G&>(objd);    //error 不能进行转换 不能讲D赋值给E
    // objg = static_cast<G>(objd); 
    
    /*
        所以，如果让以上代码通过编译，
        那么B类必须含有以A类的对象（或对象的引用）为参数的构造函数。
        如下：

        B(A& a)
        {
            // ...
        }
    */
}


int main()
{
    A *pa = new A();
    B *pb = new B();
    bar1(pa);
    C *pc = new C();
    bar1_2(pa,pc);

    bar2();

    D *pd = new D();
    bar3(pd);
    bar4();
    return 0;
}

[1] https://www.cnblogs.com/larry-xia/p/10325643.html
[2] https://blog.csdn.net/zhouwei1221q/article/details/44978361
[3] https://www.cnblogs.com/pigerhan/archive/2013/02/26/2933590.html

吐槽： Markdown真难用

Counting_Stars_
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
static_cast 和 dynamic_cast 的区别
bjzhaoxiao的专栏
04-24 1568
本文很多题目都是来源用于网上，如有侵权，请及时通知。和别人不同的是，有些题目加上了自己的思考。标记为【Jacob】第一部分:简答题1. 一下C++中static_cast 和 dynamic_cast 的区别。答：static_cast 用于有比较明确定义的变换，包括不需要强制转换的变换。【others】l  dynamic_cast 适用于类型安全的向下转换，常用在继承中的父类指针向子类指针的转...
static_cast,const_cast,reinterpret_cast,dynamic_cast
xiaowenmu1的博客
05-21 196
1.static_cast 在c++primer中提到，任何具有明确定义的类型转换，只要不包含底层const（关于什么是底层const什么是顶层const可以去c++primer看一下），都可以使用static_cast，如把double类型的对象转换成int类型的对象。但是书中没有提到的是，把一个类转换成另一个类（两个类之间没有关系）的时候编译器会报错。看下面代码。 ...
类型强制转换的区别（static_cast、dynamic_cast的区别）
02-05
类型强制转换的区别 static_cast dynamic_cast 的区别
C++的类型转换运算符（一）——static_cast 与 dynamic_cast
菜鸟的自留地-mooyang
03-31 2365
类型转换是一种机制，让程序员能够暂时或永久性改变编译器对对象的解释。注意，这并不意味着程序员改变了对象本身，而只是改变了对对象的解释。 在很多情况下，类型转换是合理的需求，可解决重要的兼容问题。因此，程序员经常需要让编译器按其所需的方式解释数据，让应用程序能够成功编译并执行。   C++编译器仍需向后兼容以确保遗留代码能够通过编译，因此支持下面这样的语法：int* pBuf = (int *
static_cast 和 dynamic_cast
TuxedoLinux的博客
01-03 1539
static_cast 和 dynamic_cast 1.static_cast static_cast &lt; type-id &gt; ( expression ) 该运算符把expression转换为type-id类型，但没有运行时类型检查来保证转换的安全性。 用法： 用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。    进行上行转换（把派生类的指针或引用转换...
static_cast和dynamic_cast详解
热门推荐
的博客
04-06 12万+
类继承关系图注：从图中可以看出，派生类不仅有自己的方法和属性，同时它还包括从父类继承来的方法和属性。当我们从派生类向基类转换时，不管用传统的c语言还是c++转换方式都可以百分百转换成功。但是可怕是向下转换类型，也就是我们从基类向派生类转换，当我们采用传统的C语言和c++转换时，就会出现意想不到的情况，因为转换后派生类自己的方法和属性丢失了，一旦我们去调用派生类的方法和属性那就糟糕了，这就是对类继承关
C++中的类型转换static_cast、dynamic_cast、const_cast和reinterpret_cast总结
09-04
本文将详细介绍四种主要的显式类型转换：`static_cast`、`dynamic_cast`、`const_cast`和`reinterpret_cast`。 首先，`static_cast`主要用于非多态类型的转换，它不提供运行时的类型检查。例如，当进行基类与子类...
由static_cast和dynamic_cast到C++对象占用内存的全面分析
08-31
在C++编程中，`static_cast`和`dynamic_cast`是两种主要的类型转换操作符，它们在处理类层次结构中的对象转换时起着至关重要的作用。本文将深入探讨这两种类型转换的区别，以及它们如何影响C++对象在内存中的占用。 ...
static_cast,dynamic_cast,reinterpret_cast,const_cast的区别及用法详解
12-31
1.static_cast对类的指针只能转换有继承关系的类。对普通的指针来说只能在void*和其他指针之间转换。它还可转换简单的类型，比如int到char等。不能提供数字到指针的转换。不能提供不同类型指针之间的转换比如int*到...
static_cast,dynamic_cast,reinterpret_cast和const_cast的区别详解
12-25
C-style cast举例： int i; double d; i = (int) d;上面的代码就是本来为double类型的d，通过(int)d将其转换成整形值，并将该值赋给整形变量i (注意d本身的值并没有发生改变)。这就是典型的c-style类型转换。下面...
static_cast与dynamic_cast转换 最简单的理解
weixin_30247781的博客
08-23 1197
3.1static_cast用法：static_cast< type-id > ( exdivssion )该运算符把exdivssion转换为type-id类型，但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法：①用于类层次结构中基类和子类之间指针或引用的转换。　　进行上行转换（把子类的指针或引用转换成基类表示）是安全的；　　进行下行转换（把基类指针或引用转换成子类...
强制类型转换 static_cast、dynamic_cast、reinterpret_cast、和const_cast
Thomas chen的专栏
05-30 874
<br />转自 http://blog.csdn.net/lemonbee/archive/2008/03/03/2143924.aspx<br /> static_cast、dynamic_cast、reinterpret_cast、和const_cast<br /> 关于强制类型转换的问题，很多书都讨论过，写的最详细的是C++ 之父的《C++ 的设计和演化》。最好的解决方法就是不要使用C风格的强制类型转换，而是使用标准C++的类型转换符：static_cast, dy
【C++】static_cast和dynamic_cast使用详解
最新发布
AAADiao的博客
01-15 1997
`static_cast` 并不执行运行时类型检查。因此，如果你尝试执行一种不安全的转换，例如将基类指针转换为不相关的派生类指针，编译器可能不会发出警告或错误，但在运行时可能会导致未定义的行为。在这种情况下，你可能需要考虑使用 `dynamic_cast`，它执行运行时类型检查，但仅在涉及多态的情况下才适用。
dynamic_cast和static_cast
kuikuitage的博客
05-31 284
百度百科 dynamic_cast将一个基类对象指针（或引用）cast到继承类指针，dynamic_cast会根据基类指针是否真正指向继承类指针来做相应处理 - 外文名: dynamic_cast - 特 点: 可以在执行期决定真正的类型 - 用 途: 类层次间的上行转换和下行转换 - 性 质: 运算符 在类层次间...
C++ static_cast和dynamic_cast
qq_44711190的博客
10-15 385
使用场景 static_cast 静态类型转换。如int转化成char reinterpret_cast 重新解释类型 dynamic_cast 命名上理解是动态类型转换,如子类和父类之间的多态类型转换 const_cast 字面上理解就是去const属性 类型转换介绍 static_cast<>() 静态类型转换,编译时c++编译器会做类型检查 若不同类型之间,进行强制类型转换,r...
static_cast与dynamic_cast的联系与区别
C++ for Windows 之路
08-13 2110
1.static_cast在编译时期强制转换,dynamic_cast在运行时期转换(较安全)       2.static_cast是c语言的强制转换代替品；dynamic_cast会运行时检查该转换是否类型安全，只在多态类型时合法，即该类至少具有一个虚拟方法。 其中
C++深入理解(11)------关于static_cast，dynamic_cast,const_cast,reinterpret_cast（读书笔记）
xiaopengshen的博客
05-11 2346
        C语言规定了很多的隐式转化，如将int转为double等，但是隐式转化时长会造成一些问题，所以在C++中定义了四种规范转换方式，来规范转化。下面依次讲述下每个转化的用法：        dynamic_cast：智能用于将派生类指针转化为基类指针，否则就会赋空值。这种转化只能用于is-a类型的转化，用法如下： BaseClass *pBase = dynamic_cast&l...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值