编程语言
首页 > 编程语言> > C++_02_类型转换

C++_02_类型转换

作者:互联网

一、旧式风格的类型转换

C++类型转换分为显式类型转换和隐式类型转换 ,隐式类型转换由编译器自动完成,这里只讨论显式类型转换。

type(expr); // 函数形式的强制类型转换
(type)expr; // C语言风格的强制类型转换

隐式类型转换是安全的,显式类型转换是有风险的,C语言之所以增加强制类型转换的语法,就是为了强调风险,让程序员意识到自己在做什么。

但是,这种强调风险的方式还是比较粗放,粒度比较大,它并没有表明存在什么风险,风险程度如何。再者,C风格的强制类型转换统一使用( ),而( )在代码中随处可见,所以也不利于使用文本检索工具定位关键代码。

为了使潜在风险更加细化,使问题追溯更加方便,使书写格式更加规范,C++ 对类型转换进行了分类,并新增了四个关键字来予以支持

二、现代C++风格的类型转换

cast-name<type>(expression)
关键字 说明
static_cast 用于良性转换,一般不会导致意外发生,风险很低。
const_cast 用于 const 与非 const、volatile 与非 volatile 之间的转换。
reinterpret_cast 高度危险的转换,这种转换仅仅是对二进制位的重新解释,不会借助已有的转换规则对数据进行调整,但是可以实现最灵活的 C++ 类型转换。
dynamic_cast 借助 RTTI,用于类型安全的向下转型(Downcasting)。

1. static_cast 关键字

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

任何编写程序时能够明确的类型转换都可以使用static_cast(static_cast不能转换掉底层const,volatile和__unaligned属性)。由于不提供运行时的检查,所以叫static_cast,因此,需要在编写程序时确认转换的安全性

主要在以下几种场合中使用:

需要注意的是,static_cast 不能用于无关类型之间的转换,因为这些转换都是有风险的,例如:

static_cast 也不能用来去掉表达式的 const 修饰和 volatile 修饰。换句话说,不能将 const/volatile 类型转换为非 const/volatile 类型。

示例:

#include <cstdlib>

using namespace std;

class Complex {
public:
    Complex(double real = 0.0, double imag = 0.0) : m_real(real), m_imag(imag) {}

    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);  //宽转换,没有信息丢失
    char ch = static_cast<char>(m);  //窄转换,可能会丢失信息
    int *p1 = static_cast<int *>( malloc(10 * sizeof(int)));  //将void指针转换为具体类型指针
    void *p2 = static_cast<void *>(p1);  //将具体类型指针,转换为void指针
    double real = static_cast<double>(c);  //调用类型转换函数

    // 下面的用法是错误的
    // float *p3 = static_cast<float*>(p1);  //不能在两个具体类型的指针之间进行转换
    // p3 = static_cast<float*>(0X2DF9);  //不能将整数转换为指针类型
    return 0;
}

2. const_cast 关键字

const_cast 比较好理解,它用来去掉表达式的 const 修饰或 volatile 修饰。换句话说,const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。

以 const 为例来说明 const_cast 的用法:

int main() {
    const int n = 100;
    int *p = const_cast<int *>(&n);
    *p = 234;
    cout << "n = " << n << endl;
    cout << "*p = " << *p << endl;

    return 0;
}

// 运行结果:
// n = 100
// *p = 234

&n 用来获取 n 的地址,它的类型为const int *,必须使用 const_cast 转换为int *类型后才能赋值给 p。由于 p 指向了 n,并且 n 占用的是栈内存,有写入权限,所以可以通过 p 修改 n 的值。

有读者可能会问,为什么通过 n 和 *p 输出的值不一样呢?这是因为 C++ 对常量的处理更像是编译时期的#define,是一个值替换的过程,代码中所有使用 n 的地方在编译期间就被替换成了 100。换句话说,第 8 行代码被修改成了下面的形式:cout<<"n = "<<100<<endl;

这样以来,即使程序在运行期间修改 n 的值,也不会影响 cout 语句了。

使用 const_cast 进行强制类型转换可以突破 C/C++ 的常数限制,修改常数的值,因此有一定的危险性;但是程序员如果这样做的话,基本上会意识到这个问题,因此也还有一定的安全性。

一般不得不使用 const_cast 的情况,都是因为前期设计的不够合理。const_cast 是不推荐使用的。

3. reinterpret_cast 关键字

reinterpret 是“重新解释”的意思,顾名思义,reinterpret_cast 这种转换仅仅是对二进制位的重新解释,不会借助已有的转换规则对数据进行调整,非常简单粗暴,所以风险很高。

非常激进的指针类型转换,在编译期完成,可以转换任何类型的指针,所以极不安全。非极端情况不要使用。

reinterpret_cast 可以认为是 static_cast 的一种补充,一些 static_cast 不能完成的转换,就可以用 reinterpret_cast 来完成,例如两个具体类型指针之间的转换、int 和指针之间的转换(有些编译器只允许 int 转指针,不允许反过来)。

示例:

class A {
public:
    A(int a = 0, int b = 0) : m_a(a), m_b(b) {}

private:
    int m_a;
    int m_b;
};

int main() {
    //将 char* 转换为 float*
    char str[] = "http://c.biancheng.net";
    float *p1 = reinterpret_cast<float *>(str);
    cout << *p1 << endl;
    //将 int 转换为 int*
    int *p = reinterpret_cast<int *>(100);
    //将 A* 转换为 int*
    p = reinterpret_cast<int *>(new A(25, 96));
    cout << *p << endl;
    cout << *(p + 1) << endl;

    return 0;
}

// 运行结果:
// 3.0262e+29
// 25
// 96

可以想象,用一个 float 指针来操作一个 char 数组是一件多么荒诞和危险的事情,这样的转换方式不到万不得已的时候不要使用。将A转换为 int,使用指针直接访问 private 成员刺穿了一个类的封装性,更好的办法是让类提供 get/set 函数,间接地访问成员变量。

4. dynamic_cast 关键字

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

dynamic_cast 与 static_cast 是相对的,dynamic_cast 是“动态转换”的意思,static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换,这就要求基类必须包含虚函数;static_cast 在编译期间完成类型转换,能够更加及时地发现错误。

对于指针,如果转换失败将返回 NULL;对于引用,如果转换失败将抛出std::bad_cast异常。

三、总结

各类cast关键字适用场景:

  1. 先考虑static_cast,能满足80%的场景;
  2. 需要向下转型时,考虑dynamic_cast;
  3. 不到万不得已不使用const_cast(通常是设计的有问题才必须用,违背了const关键字的承诺)、reinterpret_cast(比较暴力,不安全)

补充:

恕我直言,如果您100%确定所有 dynamic_cast<>正确,则没有理由不将其更改为static_cast<>的理由。您可以更改它们的

四、补充

assert_cast

写严谨代码时,也可以使用assert进行严格的条件判断。

Ref:

标签:02,类型转换,const,int,C++,cast,static,转换
来源: https://www.cnblogs.com/cloudflow/p/16366488.html