C++中的四种类型转换

1 引子

这篇笔记是根据StackOverflow上面的一个问题整理而成,主要内容是对C/C++当中四种类型转换操作进行举例说明。在之前其实对它们都是有所了解的,而随着自己在进行总结,并敲了一些测试示例代码进行验证之后,对它们的理解又深刻了一些。

总所周知,在C++ 当中引入了四种新的类型转换操作符:static_cast, dynamic_cast, reinterpret_cast,还有const_cast。就自己见过的一些C++代码当中,它们的使用其实并不普遍。不少程序员依然乐于去使用C-like的类型转换,因为它强大且编写起来又简单。据说C-Like类型转换操作符的作用实际上已经包括了static_cast, const_cast和reinterpret_cast三种操作符,你相信吗?一起来着看。

注:上面提到的C-Like类型转换操作有如下的两种形式,这一点大家一定都不会陌生。

(new-type) expression
new-type (expression)

2 static_cast vs dynamic_cast

之所以把static_cast与dynamic_cast两兄弟放在一起是因为它们两者对比起来更容易记得住。首先,从名称上面它们就有语义相对的关系,一“静”一“动”。另外,在功能上面也在一定程度上体现了这一对比的特性,如dynamic_cast的Run-time Checkingt,static_cast在编译时增加的类型检测。简单而言:

static_cast: 1)完成基础数据类型,2)同一个继承体系中类型的转换
dynamic_cast:使用多态的场景,增加了一层对真实调用对象类型的检查

2.1 从C-Like到static_cast

static_cast对于基础类型如int, float, char以及基础类型对应指针的处理大多情况下恰如C-Like的转换一样,不过static_cast会来得更加安全。

char c = 10;      // 1 个字节
int *p = (int *)&c;  // 4 个字节(32bit platform)

*p = 5;        // 内存踩脏
int *q = static_cast<int *>(&c); // 使用static_cast可在编译阶段将该错误检查出来。

对于自定义类型的处理,相比C-Like而言,它也多了一层保护,也就是它不支持在不属于同一继承体系的类型之间进行转换。但是C-Like就可以办到,看下面这个例子:

#include <iostream>

class A
{
public:
 A(){}
 ~A(){}

private:
 int i, j;
};

class C
{
public:
 C(){}
 ~C(){}

 void printC()
 {
  std::cout <<"call printC() in class C" <<std::endl;
 }
private:
 char c1, c2;
};

int main()
{
 A *ptrA = new A;
 //C *ptrC = static_cast<C *>(ptrA);
 // 编译无法通过,提示:
 // In function ‘int main()':
 // error: invalid static_cast from type ‘A*' to type ‘C*'

 C *ptrC = (C *)(ptrA);
 ptrC->printC();
 // 编译正常通过。
 // 尽管这个时候能够正常调用printC,但实际上这种做法的结果是“undefined”
 // 尝试过,如果添加一些数据成员的运算,这个时候将会使得运算结果无法预测
 // 所以,在运行时候该逻辑相关的行为是不清晰的。

 return 0;
}

2.2 static_cast对于自定义类型的转换

上面这个小例子简单对比了static_cast与C-Like在针对不同继承体系的类之间表现的差异性,现在先把范围缩小到同一继承体系当中的类型转换。(注:这里所说的类型一般是针对类的指针或者类的引用)

static_cast针对同一继承体系的类之间的转换,它既可以进行upcast也可以进行downcast。一般来说,在进行upcast时是没有问题的,毕竟子类当中一定包含有父类的相关操作集合,所以通过转换之后的指针或者引用来操作对应的对象,其行为上是可以保证没问题。这和使用static_cast与使用C-Like或者直接隐式转换效果一样(当然,其结果是否符合程序员本身的预期与当时的设计有关系)。

需要注意的是,使用static_cast进行downcast应该避免,因为它可以顺利逃过编译器的法眼,但在运行时却会爆发未定义的问题:

#include <iostream>

class A
{
public:
 A():i(1), j(1){}
 ~A(){}

 void printA()
 {
  std::cout <<"call printA() in class A" <<std::endl;
 }

 void printSum()
 {
  std::cout <<"sum = " <<i+j <<std::endl;
 }

private:
 int i, j;
};

class B : public A
{
public:
 B():a(2), b(2) {}
 ~B(){}

 void printB()
 {
  std::cout <<"call printB() in class B" <<std::endl;
 }

 void printSum()
 {
  std::cout <<"sum = " <<a+b <<std::endl;
 }

 void Add()
 {
  a++;
  b++;
 }

private:
 double a, b;
};

int main()
{
 B *ptrB = new B;
 ptrB->printSum();
 //打印结果:sum = 4
 A *ptrA = static_cast<B *>(ptrB);
 ptrA->printA();
 ptrA->printSum();
 //打印结果:sum = 2
 //在进行upcast的时候,指针指向的对象的行为与指针的类型相关。

 ptrA = new A;
 ptrA->printSum();
 //打印结果:sum = 2
 ptrB = static_cast<B *>(ptrA);
 ptrB->printB();
 ptrB->printSum();
 //打印结果:sum = 0
 //在进行downcast的时候,其行为是“undefined”。

 //B b;
 //B &rB = b;
 //rB.printSum();
 //打印结果:sum = 4
 //A &rA = static_cast<A &>(rB);
 //rA.printA();
 //rA.printSum();
 //打印结果:sum = 2
 //在进行upcast的时候,引用指向的对象的行为与引用的类型相关。

 //A a;
 //A &rA = a;
 //rA.printSum();
 //打印结果:sum = 4
 //B &rB = static_cast<B &>(rA);
 //rB.printB();
 //rB.printSum();
 //打印结果:sum = 5.18629e-317
 //在进行downcast的时候,其行为是“undefined”。

 return 0;
}

如上,static_cast在对同一继承体系的类之间进行downcast时的表现,与C-Like针对分属不同继承体系的类之间进行转换时的表现一样,将是未定义的。所以,应该尽可能使用static_cast执行downcast转换,更准确的说,应该尽可能避免对集成体系的类对应的指针或者引用进行downcast转换。

既然这样,那是不是在软件开发过程当中就不会存在downcast的这种情况了呢?实际上不是的。一般来说,进行downcast的时候一般是在虚继承的场景当中,这个时候dynamic_cast就上场了。

2.3 dynamic_cast

dynamic_cast的使用主要在downcast的场景,它的使用需要满足两个条件:

downcast时转换的类之间存在着“虚继承”的关系
转换之后的类型与其指向的实际类型要相符合
dynamic_cast对于upcast与static_cast的效果是一样的,然而因为dynamic_cast依赖于RTTI,所以在性能上面相比static_cast略低。

#include <iostream>
#include <exception>

class A
{
public:
 virtual void print()
 {
  std::cout <<"Welcome to WorldA!" <<std::endl;
 }
};

class B : public A
{
public:
 B():a(0), b(0) {}
 ~B(){}
 virtual void print()
 {
  std::cout <<"Welcome to WorldB!" <<std::endl;
 }
private:
 double a, b;
};

int main()
{
 B *ptrB = new B;
 A *ptrA = dynamic_cast<A *>(ptrB);
 ptrA->print();
 //在虚继承当中,针对指针执行upcast时dynamic_cast转换的效果与static_cast一样
 //对是否存在virtual没有要求,会实际调用所指向对象的成员。

 //A *ptrA = new A;
 //B *ptrB = dynamic_cast<B *>(ptrA);
 //ptrB->print();
 //Segmentation fault,针对指针执行downcast时转换不成功,返回NULL。

 //A a;
 //A &ra = a;
 //B &b = dynamic_cast<B &>(ra);
 //b.print();
 //抛出St8bad_cast异常,针对引用执行downcast时转换不成功,抛出异常。

 //ptrA = new A;
 //ptrB = static_cast<B *>(ptrA);
 //ptrB->print();
 //使用static_cast进行downcast的时候,与dynamic_cast返回NULL不同,
 //这里会调用ptrB实际指向的对象的虚函数。

 //ptrA = new A;
 //ptrB = dynamic_cast<B *>(ptrA);
 //ptrB->print();
 //在进行downcast时,如果没有virtual成员,那么在编译时会提示:
 // In function ‘int main()':
 // cannot dynamic_cast ‘ptrA' (of type ‘class A*') to type ‘class B*' (source type is not polymorphic)

 return 0;
}

从这个例子可以看出,在虚继承场景下,能够使用dynamic_cast的地方一定可以使用static_cast,然而dynamic_cast却有着更严格的要求,以便帮助程序员编写出更加严谨的代码。只不过,它在性能上面多了一部分开销。

3 reinterpret_cast

reinterpret_cast是最危险的一种cast,之所以说它最危险,是因为它的表现和C-Like一般强大,稍微不注意就会出现错误。它一般在一些low-level的转换或者位操作当中运用。

#include <iostream>

class A
{
public:
 A(){}
 ~A(){}
 void print()
 {
  std::cout <<"Hello World!" <<std::endl;
 }
};

class B
{
public:
 B():a(0), b(0) {}
 ~B(){}

 void call()
 {
  std::cout <<"Happy for your call!" <<std::endl;
 }

private:
 double a, b;
};

int main()
{
 //A *ptrA = new A;
 //B *ptrB = reinterpret_cast<B *>(ptrA);
 //ptrB->call();
 //正常编译
 //A *ptrA = new A;
 //B *ptrB = (B *)(ptrA);
 //ptrB->call();
 //正常编译
 //A *ptrA = new A;
 //B *ptrB = static_cast<B *>(ptrA);
 //ptrB->call();
 //编译不通过,提示:
 //In function ‘int main()':
 //error: invalid static_cast from type ‘A*' to type ‘B*'

 //char c;
 //char *pC = &c;
 //int *pInt = static_cast<int *>(pC);
 //编译提示错误:error: invalid static_cast from type ‘char*' to type ‘int*'
 //int *pInt = reinterpret_cast<int *>(pC);
 //正常编译。
 //int *pInt = (int *)(pC);
 //正常编译。

 return 0;
}

分析了static_cast,dynamic_cast与reinterpret_cast之后就可以画出如下的图示对它们之间的区别进行简单比较了。这里没有将const_cast纳入进来是因为它比较特殊,另外分节对它进行介绍。

     ----------------
     /  dynamic_cast \ -->同一继承体系(virtual)的类指针或引用[更安全的downcast]
    ~~~~~~~~~~~~~~~~~~~~
    /   static_cast  \ -->基础类型[更安全],同一继承体系的类指针或引用
   ~~~~~~~~~~~~~~~~~~~~~~~~
   /  reinterpret_cast  \ -->与C-Like的作用一致,没有任何静态或者动态的checking机制
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  /     C-Like      \ -->基础类型,同一继承体系的类指针或引用,不同继承体系类的指针或引用
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

4 const_cast

const_cast能够使用来移出或者增加一个变量的const属性,最初的时候我觉得这个const_cast比较怪异,C里面一直都没有类似的东西来消除const属性,这里是否会多余呢?其实,我这种想法本身就没根没据。后来想想,在C++当中一直提倡将常量声明为const,这样一旦常量变得多了起来,在与其他软件组件或者第三方库进行衔接的时候就难免会碰到需要cast const属性的问题。比如:

const int myConst = 15;
int *nonConst = const_cast<int *>(&myConst);

void print(int *p)
{
  std::cout << *p;
}

print(&myConst); // 编译错误:error: invalid conversion from ‘const int*' to ‘int*'
print(nonConst); // 正常

不过,在使用const_cast的时候应该要注意,如果没有必要尽量不要去修改它的值:

const int myConst = 15;
int *nonConst = const_cast<int *>(&myConst);

*nonConst = 10;
// 如果该变量存放在read-only内存区当中,在运行时可能会出现错误。

5 小结

在C++当中对于大部分数据类型而言,使用C-Like的类型转换已经完全够用了。然而,不少人一直在倡导进行显式数据类型转换的时候尽可能地使用C++规定的类型转换操作。我想这里面大概有两方面的原因:

第一种,C++是一门“新”的编程语言,应该学会用它本身的思想来解决编程方面的问题;
第二种,尽管C-Like转换操作能力强大,但如果将其任意使用,会产生不少在编译期间隐藏,却在运行时候神出鬼没。这些问题使得软件的行为极不清晰。
如此,C++当中引出了其他四种类型转换方式,用来更加安全的完成一些场合的类型转换操作。比如使用reinterpret_cast的时候会表示你确定无疑的想使用C-Like的类型转换;在使用static_cast的时候想要确保转换的对象基本兼容,比如无法将char *转换为int *,无法在不同继承体系类的指针或引用之间进行转换;而使用dynamic_cast的时候是要对虚继承下的类执行downcast转换,并且已经明了当前性能已经不是主要的影响因素......

回答一下前文提到的问题。可以这么说,对于const_cast, static_cast, reinterpret_cast和dynamic_cast所能够完成的所有转换,C-Like也可以完成。但是,C-Like转换却没有static_cast, dynamic_cast分别提供的编译时类型检测和运行时类型检测。

C++之父Bjarne Stroustrup博士在这里也谈到了他的观点,主要有两点:其一,C-Like的cast极具破坏性并且在代码文本上也难得花不少力气搜索到它;其二,新式的cast使得程序员更有目的使用它们并且让编译器能够发现更多的错误;其三,新的cast符合模板声明规范,可以让程序员编写它们自己的cast。

时间: 2015-08-24

浅谈C++的语句语法与强制数据类型转换

一个程序包含一个或多个程序单位(每个程序单位构成一个程序文件).每一个程序单位由以下几个部分组成: 预处理命令.如#include命令和#define命令. 声明部分.例如对数据类型和函数的声明,以及对变量的定义. 函数.包括函数首部和函数体,在函数体中可以包含若干声明语句和执行语句. 如下面是一个完整的C++程序: #include <iostream>//预处理命令 using namespace std; //在函数之外的声明部分 int a=3; //在函数之外的声明部分 int ma

C++编程中的数据类型和常量学习教程

C++数据类型 计算机处理的对象是数据,而数据是以某种特定的形式存在的(例如整数.浮点数.字符等形式).不同的数据之间往往还存在某些联系(例如由若干个整数组成一个整数数组).数据结构指的是数据的组织形式.例如,数组就是一种数据结构.不同的计算机语言所允许使用的数据结构是不同的.处理同一类问题,如果数据结构不同,算法也会不同.例如,对10个整数排序和对包含10个元素的整型数组排序的算法是不同的. C++的数据包括常量与变量,常量与变量都具有类型.由以上这些数据类型还可以构成更复杂的数据结构.例如利

C++运行时获取类型信息的type_info类与bad_typeid异常

type_info 类 type_info 类描述编译器在程序中生成的类型信息.此类的对象可以有效存储指向类型的名称的指针. type_info 类还可存储适合比较两个类型是否相等或比较其排列顺序的编码值.类型的编码规则和排列顺序是未指定的,并且可能因程序而异. 必须包含 <typeinfo> 标头文件才能使用 type_info 类. type_info 类的接口是: class type_info { public: virtual ~type_info(); size_t hash_co

深入解析C++中的动态类型转换与静态类型转换运算符

dynamic_cast 运算符 将操作数 expression 转换成类型为type-id 的对象. 语法 dynamic_cast < type-id > ( expression ) 备注 type-id 必须是一个指针或引用到以前已定义的类类型的引用或"指向 void 的指针".如果 type-id 是指针,则expression 的类型必须是指针,如果 type-id 是引用,则为左值. 有关静态和动态强制转换之间区别的描述,以及各在什么情况下适合使用,请参见 s

解析C#中的私有构造函数和静态构造函数

私有构造函数 私有构造函数是一种特殊的实例构造函数.它通常用在只包含静态成员的类中.如果类具有一个或多个私有构造函数而没有公共构造函数,则其他类(除嵌套类外)无法创建该类的实例.例如: class NLog { // Private Constructor: private NLog() { } public static double e = Math.E; //2.71828... } 声明空构造函数可阻止自动生成默认构造函数.注意,如果您不对构造函数使用访问修饰符,则在默认情况下它仍为私有

JSP页面的动态包含和静态包含示例及介绍

一.静态包含 本文介绍JSP静态包含语句,即使用JSP的include指令来完成的包含操作. JSP中,有两种包含其它文件的方式,一种是静态包含,一种是动态包含.本文介绍其中的静态包含. 所谓静态包含,跟ASP中的包含是一样的效果,即将所有包含的文件,先静态的包含进来,组成一个大的JSP文件,然后再经过编译器统一编译,生成HTML代码. JSP静态包含的语句为: 复制代码 代码如下: <%@ include file="file.jsp" %> 这里的file.jsp就是要

Mybatis中的动态SQL语句解析

这篇文章主要介绍了Mybatis中的动态SQL语句解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Mybatis中配置SQL有两种方式,一种是利用xml 方式进行配置,一种是利用注解进行配置. Mybatis使用注解配置SQL,但是由于配置功能受限,而且对于复杂的SQL而言可读性很差,所以很少使用. Mybatis常用xml配置的方式,使用xml的几个简单的元素,便能完成动态SQL的功能,大量的判断都可以在mybaties的映射xml里面配

JSON中key动态设置及JSON.parse和JSON.stringify()的区别

本文给大家介绍JSON中key动态设置及JSON.parse和JSON.stringify()的区别讲解,具体详情如下所示: var user_info_json = []; user_info_json[user_info_json.length] = eval('('+ '{"'+ id +'": "'+ value +'"}' +')'); JSON.stringify(user_info_json) 先转成字符串,然后使用eval()格式化,然后在把json

php中的动态调用实例分析

本文实例讲述了php中的动态调用具体用法.分享给大家供大家参考.具体分析如下: 在程序中如果加一大堆判断的确是一个很大的麻烦,例如这样: 复制代码 代码如下: if($fun='a'){echo "哎呀!";} elesif(){} -- else{echo "嗯!";} 真的很麻烦并且造成程序后期阅读和修改时候的巨大麻烦,这时候我们可以把每一个要执行的代码段,用函数来实现,然后可以用一个更加NB的方法来实现这些功能,并且因为每一个函数实现一个功能,我们维护起来就简

浅谈如何使用python抓取网页中的动态数据实现

我们经常会发现网页中的许多数据并不是写死在HTML中的,而是通过js动态载入的.所以也就引出了什么是动态数据的概念,动态数据在这里指的是网页中由Javascript动态生成的页面内容,是在页面加载到浏览器后动态生成的,而之前并没有的. 在编写爬虫进行网页数据抓取的时候,经常会遇到这种需要动态加载数据的HTML网页,如果还是直接从网页上抓取那么将无法获得任何数据. 今天,我们就在这里简单聊一聊如何用python来抓取页面中的JS动态加载的数据. 给出一个网页:豆瓣电影排行榜,其中的所有电影信息都是

解析SpringCould中的Hystrix

一.简介 源码地址:https://gitee.com/xiaocheng0902/my-cloud.git 1,定义 Hystrix是一个用于处理分布式系统的延迟和容错的开源库,在分布式系统里,许多依赖不可避免的会调用失败,比如超时.异常等.Hystrix能够保证在一个依赖出问题的情况下,不会导致整体服务失败,避免级联故障,以提高分布式系统的弹性. "断路器"本身是一种开关装置,当某个服务单元发生故障之后,通过断路器的故障监控(类似熔断保险丝),向调用方返回一个符合预期的.可处理的备

vue中v-model动态生成的实例详解

vue中v-model动态生成的实例详解 前言: 最近在做公司的项目中,有这么一个需求,每一行有一个input和一个select,其中行数是根据服务器返回的json数据动态变化的.那么问题来了,我们要怎样动态生成v-model? 现在项目做完了就整理了一下,直接贴代码了. <!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> <

spring mvc中的@PathVariable获得请求url中的动态参数

spring mvc中的@PathVariable是用来获得请求url中的动态参数的,十分方便,复习下: @Controller public class TestController { @RequestMapping(value="/user/{userId}/roles/{roleId}",method = RequestMethod.GET) public String getLogin(@PathVariable("userId") String user