C++四种类型转化

最新推荐文章于 2023-06-01 23:45:00 发布

kerongw

最新推荐文章于 2023-06-01 23:45:00 发布

阅读量1.2k

点赞数 4

分类专栏： C++

博客所有文章可能来自某个网站的文章，或某个网友的评论，或其他人的博客。我这里仅仅当做笔记记录，版权归原文章所有

本文链接：https://blog.csdn.net/qq_43469158/article/details/110680163

版权

C++ 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

1、static_cast

static_case:静态转型（向上转型）。用于以下类型转换

原有类型的自动类型转换，如short转int，int转double，向上转型等
void指针和具体类型指针的转换，如void *转int *， int *转void *， double *转void *等等。但是不能在具体类型指针之间转换，例如int *转double *、Student *转int *等。不同类型的数据存储格式不一样，长度也不一样，用 A 类型的指针指向 B 类型的数据后，会按照 A 类型的方式来处理数据：如果是读取操作，可能会得到一堆没有意义的值；如果是写入操作，可能会使 B 类型的数据遭到破坏，当再次以 B 类型的方式读取数据时会得到一堆没有意义的值。
int 和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的，因为该地址上的内存可能没有分配，也可能没有读写权限，恰好是可用内存反而是小概率事件。如 int * p = (int *)0x12345，这样做在嵌入式领域没问题，但在C++中是很危险的操作

static_cast 是“静态转换”的意思，也就是在编译期间转换，转换失败的话会抛出一个编译错误。

#include <iostream>
using namespace std;

class Complex{
public:
    Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
public:
    operator double() const { return m_real; }  //类型转换函数
private:
    double m_real;
    double m_imag;
};

int main(){
    //下面是正确的用法
    int m = 100;
    Complex c(12.5, 23.8);
    long n = static_cast<long>(m);  //宽转换，没有信息丢失，int=>long
    char ch = static_cast<char>(m);  //窄转换，可能会丢失信息，int=>char
    int *p1 = static_cast<int*>( malloc(10 * sizeof(int)) );  //将void指针转换为具体类型指针,void*=>int*
    void *p2 = static_cast<void*>(p1);  //将具体类型指针，转换为void指针,int*=>void*
    double real= static_cast<double>(c);  //调用类型转换函数,Complex=>double
   
    //下面的用法是错误的
    float *p3 = static_cast<float*>(p1);  //不能在两个具体类型的指针之间进行转换,int *=>float *
    int *p4 = static_cast<int *>(0X2DF9);  //不能将整数转换为指针类型   危险

    return 0;
}

2、const_cast

用于 const 与非 const、volatile 与非 volatile 之间的转换。

#include <iostream>
using namespace std;

int main(int argc, char const *argv[])
{
    const int num = 100;
    //错误。const只读，不能修改
    num = 200;

    //num的地址0x61ff08
    cout<<&num<<endl;
    int &temp = const_cast<int &>(num); //这里传num的引用，将const转换成非const
   //temp的地址0x61ff08，temp和num就是一个东西
    cout<<&temp<<endl;; //temp = 100;

    cout<<num<<endl;    //num =100;
    temp = 200;

    cout<<num<<endl; //num = 100;这里明明用引用变量temp对它修改了呀为什么不是200而是100呢
    //因为C++ 对常量的处理更像是编译时期的#define，是一个值替换的过程，代码中所有使用num的地方在“编译期间”就被替换成了100

    cout<<temp; //200

    return 0;
}

3、dynamic_cast

dynamic_cast 用于在类的继承层次之间进行类型转换，它既允许向上转型（Upcasting），也允许向下转型（Downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助 RTTI 进行检测，所有只有一部分能成功。

dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。

使用格式：dynamic_cast<指针/引用>(指针/引用)

作用：将一个基类对象指针（或引用）转到到继承类指针（或引用），dynamic_cast会根据基类指针是否真正指向继承类指针来做相应处理，即会作出一定的判断。
若对指针进行dynamic_cast，失败返回null，成功返回正常cast后的对象指针；
若对引用进行dynamic_cast，失败抛出一个异常，成功返回正常cast后的对象引用。

3.1 向上转型

向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的。

#include <iostream>
using namespace std;

class Base
{
public:
    int m_bge;
    Base(int bge):m_bge(bge){};
    virtual void printf()
    {
        cout<<"base class"<<endl;
    }
    void fun()
    {
        cout<<"base fun"<<endl;
    }

};

class Turp : public Base
{
public:
    int m_tge;
    Turp(int tge, int bge):m_tge(tge),Base(bge){};
    void printf()
    {
        cout<<"Turp class"<<endl;
    }
    void fun()
    {
        cout<<"Turp fun"<<endl;
    } 
};

int main(int argc, char const *argv[])
{
    Turp * t = new Turp(10,20);
    Base *b = dynamic_cast<Base *>(t);
    b->fun();
    cout<<b->m_bge; //输出20

    delete t;
    t = nullptr;

    return 0;
}

3.2 向下转型

#include <iostream>
using namespace std;
//继承关系A=>B=>C=>D
class A
{
public:
    virtual void printf()
    {
        cout<<"class A"<<endl;
    }
    void fun1(){cout<<"Class A fun1"<<endl;};
};
class B : public A
{
public:
    virtual void printf()
    {
        cout<<"class B"<<endl;
    }
    void fun1(){cout<<"Class B fun1"<<endl;};
};
class C : public B
{
public:
    virtual void printf()
    {
        cout<<"class C"<<endl;
    }
    void fun1(){cout<<"Class C fun1"<<endl;};
};
class D : public C
{
public:
    virtual void printf()
    {
        cout<<"class D"<<endl;
    }
    void fun1(){cout<<"Class D fun1"<<endl;};
};

int main(int argc, char const *argv[])
{
    A *a = new A;
/*********************①*************************/
    //A=>B 失败
    B *b = dynamic_cast<B *>(a);
    if(b!=nullptr)
    {
        cout<< "SUCCESS:A=>B "<<endl;
    }
    else
    {
        cout<< "FAILE:A=>B "<<endl;
    }
    
    //A=>C失败
    C *c = dynamic_cast<C *>(a);
    if(b!=nullptr)
    {
        cout<< "SUCCESS:A=>C "<<endl;
    }
    else
    {
        cout<< "FAILE:A=>C "<<endl;
    }
    delete a;
/*********************②*************************/
    //A=>B成功
    a = new C;
    b = dynamic_cast<B*>(a);
    if(b!=nullptr)
    {
        cout<< "SUCCESS:A=>B  ";
        b->fun1();
    }
    else
    {
        cout<< "FAILE:A=>B "<<endl;
    }
    delete a;

    //A=>C成功
    a = new D;
    c = dynamic_cast<C*>(a);
    if(c!=nullptr)
    {
        cout<< "SUCCESS:A=>C  ";
        c->fun1();
    }
    else
    {
        cout<< "FAILE:A=>C "<<endl;
    }
    delete a;
    
    return 0;
}

先申请了A类型的对象，然后转换为B类型，直接失败。紧接着A类型继续转换为C类型还是失败。向下转换类型失败。
后面申请了一个C类型的对象，使用A类型的指针去接收（即父类指针指向子类对象）。此时将A类型的指针a*转换成B*类型。显示转换转换成功（A类型转换成B类型）。
同理申请了一个D类型的对象，使用A类型去接收（即父类指针指向子类对象）。此时将A类型的指针a*转换成C类型。显示转换转换成功（A类型转换成C类型）。

同样是向下转换为什么后两种可以呢？

诀窍是：

假设现有继承关系A(基类)=>B=>C=>D=>E=>F(派生类)，我现在要将B类转换成C类型（B=>C），我只需要让B类型的指针/引用指向C类的子类（DEF类）的对象。然后使用dynamic_cast（）将B类的指针/引用转换成C类的指针或引用，即可转换成功。即要让被转换的类的指针/引用指向‘转换到的类’的子类的对象，即可转换成功

原理：有虚函数存在时，每个类都会在内存中保存一份类型信息，编译器会将存在继承关系的类的类型信息使用指针“连接”起来，从而形成一个继承链（Inheritance Chain），也就是如下图所示的样子：

当使用 dynamic_cast 对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。

对于本例①的情况来说，b指向A类型的对象，根据对象找到的就是A的类型信息，当程序从这个节点开始向上遍历时，发现A类的上面没有要转换的B类和C类，所以就转换失败了。

对于本例②的情况来说，a指向C类型的对象，根据对象找到的就是C的类型信息，当程序从这个节点开始向上遍历时，发现C类的上面有我们要转换的B类，所以就转换成功了。最后一个同理。

总起来说，dynamic_cast 会在程序运行过程中遍历继承链，如果途中遇到了要转换的目标类型，那么就能够转换成功，如果直到继承链的顶点（最顶层的基类）还没有遇到要转换的目标类型，那么就转换失败。对于同一个指针（例如a），它指向的对象不同，会导致遍历继承链的起点不一样，途中能够匹配到的类型也不一样，所以相同的类型转换产生了不同的结果
从表面上看起来 dynamic_cast 确实能够向下转型，本例也很好地证明了这一点：B 和 C 都是 A 的派生类，我们成功地将 a 从 A 类型指针转换成了 B 和 C 类型指针。但是从本质上讲，dynamic_cast 还是只允许向上转型，因为它只会向上遍历继承链。造成这种假象的根本原因在于，派生类对象可以用任何一个基类的指针指向它，这样做始终是安全的。

虚函数对于dynamic_cast转换的作用

为何使用dynamic_cast转换类指针时，需要虚函数呢。Dynamic_cast转换是在运行时进行转换，运行时转换就需要知道类对象的信息（继承关系等）。如何在运行时获取到这个信息——虚函数表。

　　C++对象模型中，对象实例最前面的就是虚函数表指针，通过这个指针可以获取到该类对象的所有虚函数，包括父类的。因为派生类会继承基类的虚函数表，所以通过这个虚函数表，我们就可以知道该类对象的父类，在转换的时候就可以用来判断对象有无继承关系。

所以虚函数对于正确的基类指针转换为子类指针是非常重要的。

4、reinterpret_cast

reinterpret_cast 这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，非常简单粗暴，所以风险很高。 static_cast 不能完成的转换，就可以用 reinterpret_cast 来完成，例如两个具体类型指针之间的转换、int 和指针之间的转换（有些编译器只允许 int 转指针，不允许反过来）。

kerongw

关注

4
点赞
踩
8

收藏

觉得还不错? 一键收藏
0
评论
C++四种类型转化

1、static_cast2、const_cast3、dynamic_cast3.11、static_caststatic_case:静态转型（向上转型）。用于以下类型转换原有类型的自动类型转换，如short转int，int转double，向上转型等 void指针和具体类型指针的转换，如void *转int *，int *转void *，double*转void *等等。但是不能在具体类型指针之间转换，例如int *转double *、Student *转int *等。不同...
复制链接

扫一扫