«

C++中常用的四种类型转换方式是什么

时间:2024-4-15 08:57     作者:韩俊     分类: Java


本篇内容介绍了“C++中常用的四种类型转换方式是什么”的有关知识,在实际案例的操作过程中,不少人都会遇到这样的困境,接下来就让小编带领大家学习一下如何处理这些情况吧!希望大家仔细阅读,能够学有所成!

1.静态类型转换:static_cast(exp)

1.1静态类型转换主要用于两种转换环境

1.1.1 C++内置类型的转换:与C风格强转类似。

与c相同的地方:

#include <iostream>
 
using namespace std;
 
int main()
{
    double a=3.14;
 
    cout << static_cast<int>(a) << endl;
 
    return 0;
}

不同的地方就是使用static_cast不能强转内置类型指针的,这点可以避免C风格中的越界问题。

如图所示:

1.1.2当有继承关系存在时的强转:

如果使用static_cast 由子类向父类转型,向上转型,天然安全安全。(应为子类的空间肯定比父类的空间大,子类是在继承父类的空间上面开辟),代码如下:

#include <iostream>
 
using namespace std;
 
class A
{
public:
    int a=100;
 
    void Ashow_info()
    {
        cout<<this->a<<endl;
    }
};
 
class B:public A
{
public:
    int a=200;
    int b=300;
    int c=400;
    void Bshow_info()
    {
        cout<<this->a<<this->b<<this->c<<endl;
    }
};
 
 
int main()
{
   B* a=new B;
   static_cast<A*>(a)->Ashow_info();
 
    return 0;
}

结果图:

我们可以通过子类安全的访问到父类中的a值。

如果使用static_cast 由父类向子类转型,向下转型,是不安全。

那么何时不安全?何时安全?

不安全的情况介绍:

#include <iostream>
 
using namespace std;
 
class A
{
public:
    int a=100;
 
    void Ashow_info()
    {
        cout<<this->a<<endl;
    }
};
 
class B:public A
{
public:
    int a=200;
    int b=300;
    int c=400;
    void Bshow_info()
    {
        cout<<this->a<<this->b<<this->c<<endl;
    }
};
 
 
int main()
{
   A* a=new A;
   static_cast<B*>(a)->Bshow_info();
 
    return 0;
}

结果图:

如图所示结果中并没有出现本应该打出的200,300,400,这就是不知道子类空间是否被开辟而向下访问造成的结果。

安全的情况:

#include <iostream>
 
using namespace std;
 
class A
{
public:
    int a=100;
 
    void Ashow_info()
    {
        cout<<this->a<<endl;
    }
};
 
class B:public A
{
public:
    int a=200;
    int b=300;
    int c=400;
    void Bshow_info()
    {
        cout<<this->a<<this->b<<this->c<<endl;
    }
};
 
 
int main()
{
   A* a=new B;
   static_cast<B*>(a)->Bshow_info();
 
    return 0;
}

结果图:

如图所示,此时我们可以打出200,300,400,等数值,说明当我们知道子类空间被开辟时候,就可以安全的向下访问。

2.动态类型转换:dynamic_cast(exp)

2.1概念

动态类型转换是依赖于虚函数的与继承关系,没有虚函数,就无法使用动态类型转换。dynamic_cast是一个安全类型转换,因为他是依赖于函数实现动态转型。因为虚表中的第一个Slot位置保存了类型运行识别信息。

注意使用的条件为:1)要有继承关系 2)要有虚函数。

这个虚表的结构:

2.2代码举例说明

#include <iostream>
 
using namespace std;
 
class A
{
public:
 
 
    virtual void show_info()
    {
        cout<<"我是父亲"<<endl;
    }
};
 
class B:public A
{
public:
 
    void show_info()
    {
        cout<<"我是儿子"<<endl;
    }
};
 
 
int main()
{
   A* a=new B;
   dynamic_cast<B*>(a)->show_info();
 
    return 0;
}

结果图:

3.常类型转换:const_case(exp)

就是用来修改const修饰的常引用和常指针的转换方式

3.1代码说明

#include <iostream>
 
using namespace std;
 
int main()
{
    const int& a=100;
 
    const_cast<int&>(a)=200;
 
    cout<<a<<endl;
 
 
    return 0;
}

结果图:

由图可知我们修改了常引用的数值。

4. 解释类型转换: reinterpret_cast(exp)

4.1概念

这要类型转换方式,是可以庆用于任何类型,他的底层的实现就是对底层二进制数据的一个拷贝。所以也是一个不安全的强转。

4.2由于这个一般都不用,从我们最有可能的会用到的情况下抽出来一种,代码如下:

当我们想把一个数的地址,用10进制的表达出来的时候,如下,光一个int 是装不下地址的十进制,所以系统就会给我们报错。

 这个时候reinterpert_cast就起到了作用,我们可以把他转为long long类型,如下:

#include <iostream>
 
using namespace std;
 
int main()
{
  int a=10;
 
  int *p=&a;
 
 
  cout<<reinterpret_cast<long long>(p)<<endl;
    return 0;
}

结果图:

标签: java

热门推荐