static_cast、dynamic_cast、const_cast和reinterpret_cast总结

最新推荐文章于 2024-08-15 15:21:30 发布

youngyoungla

最新推荐文章于 2024-08-15 15:21:30 发布

阅读量411

点赞数 1

分类专栏： c/c++知识点面试题

本文链接：https://blog.csdn.net/youngyoungla/article/details/52557218

版权

c/c++知识点面试题专栏收录该内容

6 篇文章 0 订阅

订阅专栏

c++类型转换：

（1）显示类型转换

（2）隐式类型转换

而对于隐式变换，就是标准的转换，在很多时候，不经意间就发生了，比如int类型和float类型相加时，int类型就会被隐式的转换位float类型，然后再进行相加运算。

接下来主要介绍显示类型转换。

一、static_cast

static_cast的转换格式：static_cast <type-id> (expression)

将expression转换为type-id类型，主要用于非多态类型之间的转换，不提供运行时的检查来确保转换的安全性。主要在以下几种场合中使用：

用于类层次结构中，基类和子类之间指针和引用的转换；
当进行上行转换，也就是把子类的指针或引用转换成父类表示，这种转换是安全的；
当进行下行转换，也就是把父类的指针或引用转换成子类表示，这种转换是不安全的，也需要程序员来保证；
用于基本数据类型之间的转换，如把int转换成char，把int转换成enum等等，这种转换的安全性需要程序员来保证；
把void指针转换成目标类型的指针，是及其不安全的；

注：static_cast不能转换掉expression的const、volatile和__unaligned属性

二、dynamic_cast

dynamic_cast的转换格式：dynamic_cast <type-id> (expression)

将expression转换为type-id类型，type-id必须是类的指针、类的引用或者是void *；如果type-id是指针类型，那么expression也必须是一个指针；如果type-id是一个引用，那么expression也必须是一个引用。

dynamic_cast主要用于类层次间的上行转换和下行转换，还可以用于类之间的交叉转换。在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。在多态类型之间的转换主要使用dynamic_cast，因为类型提供了运行时信息。下面我将分别在以下的几种场合下进行dynamic_cast的使用总结：

（1）单继承，多继承上行转换是安全的

（2）下行转换：从基类指针转换到派生类指针。

如果expression是type-id的基类，使用dynamic_cast进行转换时，在运行时就会检查expression是否真正的指向一个type-id类型的对象，如果是，则能进行正确的转换，获得对应的值；否则返回NULL，如果是引用，则在运行时就会抛出异常；

#include<iostream>
#include<string>
using namespace std;
class person
{
public:
person(const char* name,const char* sex,int age)
 :_name(name)
 ,_sex(sex)
 ,_age(age)
{
   cout<<"person()"<<endl;
}
virtual void Display()
{
   cout<<"name:"<<_name<<"sex:"<<_sex<<"age:"<<_age<<endl;
}
virtual ~person() //析构函数为虚函数
{
  cout<<"~person"<<endl;
}
private:
 string _name;
 string _sex;
 int _age;
};
class teacher :public person
{
public:
  teacher(const char* name,const char* sex,int age,const char* subject)
    :person(name,sex,age)
    ,_subject(subject)
{
cout<<"teacher()"<<endl;
}
~teacher()
{
cout<<"~teacher"<<endl;

}
void Display()
{
  cout<<"subject:"<<_subject<<endl;
}
private:
string _subject;
};
void fun(person& p) //实现多态
{
 p.Display();
}
void test()
{
 //person p1("zyc","女",20);
//teacher t1("www","nan",23,"math");
 //fun(p1);
//fun(t1);


person* p=dynamic_cast<person*> (new teacher("lulu","nv",23,"yuyan"));
delete p;  //通过指针访问时，必须动手delete释放；

teacher* t=dynamic_cast<teacher*> (new person("lala","nan",12)); //子类指针指向父类，必须强转
if(t==NULL)
{
  cout<<"为空";
}
delete t;


}
int main()
{
test();
system("pause");
return 0;
}

结果：

比如：D继承B

     B* pb = new D;   // unclear but ok
     B* pb2 = new B;
     D* pd = dynamic_cast<D*>(pb);   // ok: pb actually points to a D
     D* pd2 = dynamic_cast<D*>(pb2);   // pb2 points to a B not a D, now pd2 is NULL

（3）对于一些复杂的继承关系来说，使用dynamic_cast进行转换是存在一些陷阱的；比如，有如下的一个结构：

D类型可以安全的转换成B和C类型，但是D类型要是直接转换成A类型呢？

class A
{
virtual void Func() = 0;
};
class B : public A
{
void Func(){};
};
class C : public A
{
void Func(){};
};
class D : public B, public C
{
void Func(){}
};
int main()
{
D *pD = new D;
A *pA = dynamic_cast<A *>(pD); // You will get a pA which is NULL
}
如果进行上面的直接转，你将会得到一个NULL的pA指针；这是因为，B和C都继承了A，并且都实现了虚函数Func，导致在进行转换时，无法进行抉择应该向哪个A进行转换。正确的做法是：

int main()
{
D *pD = new D;
B *pB = dynamic_cast<B *>(pD);
A *pA = dynamic_cast<A *>(pB);
}
这就是我在实现QueryInterface时，得到IUnknown的指针时，使用的是*ppv = static_cast<IX *>(this);而不是*ppv = static_cast<IUnknown *>(this);

对于多重继承的情况，从派生类往父类的父类进行转时，需要特别注意；比如有下面这种情况：