一.隐式转换
C++本身提供的类型转换分为隐式和显式两种类型。其中隐式转换主要是指:
①算术转换:如int+double之后,算术结果会完成从int到高精度的double的转换。
②表达式转换:int iVal = double dVal, dVal会完成从double到int 的转换。
③实参调用转换:将double型输入要求int型输入的函数里,完成该转换。
void f(int i)
{};
double d = 2.00;
f(d);
这段代码中,d在作为实参进入f函数时,完成了从double到int的转换。
④返回值转换:函数返回值类型与输入值类型不匹配,系统自动转换。
double difference(int ival1, int ival2)
{
return ival1 - ival2;
//返回值被提升为double类型
}
之所以叫隐式转换,是因为我们在操作的过程中,类型的转换完全是由编译器后台完成了,而作为用户的我们实际上看不到这个转换的过程,也无须介入转换的执行。
引用一段《C++primer》的原文:
除了以上情况,另外还有:
数据类型向指针的转换:
int i[10];int *ip = i;//在这段代码中,数组i被转换成了指针ip
指针之间的转换:
比如Nullptr空白指针可以被转换为任意指针类型。
非常量到常量的转换:
int i;
const int &j = i;//非常量数据类型转换为常量引用
const int *p = &i;//非常量引用转换为const 地址
以上是隐式转换的常见场景。
隐式转换一般被认为是安全的,因为它转换的两种对象之间存在关联关系。而当你将无关联关系的对象进行互相转换时,编译器会报错,从而阻止转换的发生。隐式转换无需人为干涉,转换的过程被隐藏。
二.显式转换
上文我们说到,隐式转换一般用于存在关联关系的两个对象之间的转换,例如double和int之间的转换。
有时候面对没有关联关系的两者,我们需要对它们进行强制性的转换。这种转换可以直接在代码上进行体现:
int i,j;
double result = double( i/j );// i/j本质还是int型,需要加double强制转换成double型
代码中的double()就是一种显式的强制转换,这类强制转换叫做cast。
显示转换的标准格式:cast-name<type>(expression)
cast-name: 转换形式 <type> : 转换类型 (expression) : 转换对象
显示转换一共提供了四种转换形式,static-cast,const-cast,dynamic-cast和reinterpret-cast。
1.static-cast
CheckStaticCast - Check that a static_cast(SrcExpr) is valid.Refer to C++ 5.2.9 for details. Static casts are mostly used for making implicit conversions explicit and getting rid of data loss warnings.—[Clang源码]
根据Clang源码的解释,static_cast<>大部分情况下用于对隐式转换的显示化,同时去掉相关warning报警。
什么意思呢,比方我有一个double型变量,我想把它转换成int型,这时候我只需要写:
i = d 就行了,编译能够通过,运行也毫无问题,只是编译器会给出一个warning提示,告诉你将double转换到int时损失了精度。
所以你可以使用 i = static_cast<int>(d) 这种写法,来消除编译器给出的warning提示,完成一次强制显式转换。
需要注意的是,static_cast并不是能转换所有类型,当毫无关联的两个类之间进行相互转换时,即使使用static_cast也不会通过。
class A{
type a;
};
class B{
type b;
};
int MyMain(A a, B b){
b = static_cast<B>(a);
//上一行编译器会报错,阻止两个毫无关联类之间的转换
}
因为在逻辑上,A和B是两个毫不相关的类。但是如果定义了明确的类型定义后,这种不同对象之间的转换就是允许的。例如给Class B添加了类型为A的单参数构造函数后,就可以编译通过。
class A{
type a;
};
class B{
public:
B(const A& lhs) {}
};
int MyMain()
{
A a;
// static_cast<B>(a)直接调用B(const A& lhs)构造函数
B b = static_cast<B>(a);
// 编译通过,转换完成
}
如果一个构造函数只接受一个实参,则它实际上定义了转换此类类型的隐式转换机制,有时我们把这种构造函数称作转换构造函数(converting constructor)。 —-Primer 5th
在上一段代码中,B的构造函数实际只有A一个实参,因此可以对类型A进行强制转换,完成到B的转换过程。
2.const_cast
static_cast并不是万能的,除了不能对毫无关联的类进行转换外,也不能对const修饰的常量进行转换。
因此引申出了const_cast转换类型,顾名思义,用于去除被const修饰的对象的const属性。
需要注意的是,const_cast只能改变运算对象的底层const。const_cast不能改变表达式的类型,也不能改变变量本身。
什么意思呢,以下用一段代码来说明const_cast的作用:
using namespace std;
int main(int argc, CHAR* argv[])
{
const int val=13; // 定义一个常量数值
int temp=15; // 定义一个非常量数值
const int* ptr=&temp; // 定义一个常量指针指向非常数值
int* p=const_cast<int*>(ptr); // 执行解常量转换
*p = 16; // 改地址成功
// (*ptr)++; // 失败,解除引用的值依旧是const
ptr++; // 成功,说明指针已经不是常量了
// (*ptr)++; // 失败,指针+1了,指向下一个地址了,但其解除引用后依旧是const
ptr--; // 成功,同上
return 0;
}
很明显,const_cast对于指针的解常量是有用的,但是并不会改变常量本身的数值,只能把指向数值的常量指针解除常量属性以改指向另一个地址。
Class B{
int m_iNum = 0;
}
int MyMain{
const B *b1 = new B();
//b1->m_iNum = 1; // 编译错误,因为b1是常量指针,指向的地址无法更改
B *b2 = const_cast<B*>(b1);// 解常量属性
b2->m_iNum = 1; // 修改成功
// 此时b1和b2都为1
const B b3;
//b3.m_iNum = 1; // error,常量无法修改
B b4 = const_cast<B&>(b3); // 解除数值本身的常量属性
b4.m_iNum = 1;
// 此时,b3 = 0, b4 = 1
// 常量引用被转换成非常量引用,但是仍然指向原来的对象;
const B b5;
//b5.m_iNum = 1; // error
// 左侧也可以用引用类型,如果对b6的数据成员做改变,就是对b5的值在做改变
B &b6 = const_cast<B&>(b5);
b6.m_iNum = 1;
// 此时, b5 = 1, b6 = 1
// 解除常量属性后,使用引用方式直接改变数值本身
return 0;
}
因此,const_cast的用法可以总结为:
-
一、常量指针被转化成非常量指针,并且仍然指向原来的对象;
-
二、常量引用被转换成非常量引用,并且仍然指向原来的对象;
-
三、常量对象被转换成非常量对象。
3.dynamic_cast
dynamic_cast主要用于类层次间的上行转换和下行转换,以及类之间的交叉转换。
同样举个例子说明:
class Basic{
public:
virtual int funcA();
}
// 以上定义一个基类
class ChildrenA : public Basic{
public:
int funcChildrenA();
}
int MyMain(){
Basic b;
childrenA * a = dynamic_cast< Children* > b;
}
在实际的生产中,基类往往是随着动态库一起封装在头文件里给开发者使用的。这个时候基类是不能进行扩展的,失去了虚函数的衍生性支持,开发者想要在基类上拓展功能,可以选择将新建的基类用dynamic_cast进行转换变成子类,同时在其它地方实现子类自定义的函数 funcchildrenA。
那么你可能要问了,static_cast也能实现这个功能,所以
static_cast 和 dynamic_cast 的区别是什么?
回到以上那段代码:
int MyMain(){
Basic b = new Children;
ChildrenA * a = dynamic_cast< Children* > b;
ChildrenA * c = static_cast< Children* > b;
}
在上面的代码段中,如果b实际指向一个Children 类型的对象,a 和 c 是一样的,并且对这两个指针执行Children类型的任何操作都是安全的;
如果b实际指向的是一个Basic类型的对象(如图中例子),那么a将是一个指向该对象的指针,对它进行Children类型的操作将是不安全的,而c将是一个空指针(即nullptr,因为dynamic_cast失败)。
因此,对以上代码进行修改:
int MyMain(){
Basic b = new Basic;
ChildrenA * a = dynamic_cast< Children* > b;// 通过
// ChildrenA * c = static_cast< Children* > b;// 直接报错
}
另外要注意:b 要有虚函数,否则会编译出错;static_cast则没有这个限制。
这是由于运行时类型检查需要运行时类型信息,而这个信息存储在类的虚函数表(关于虚函数表的概念,详细可见<Inside c++ object model>)中,只有定义了虚函数的类才有虚函数表,没有定义虚函数的类是没有虚函数表的。
这块博主不过多做解释,直接一个百度百科的复制粘贴:
在C++的面对对象思想中,虚函数起到了很关键的作用,当一个类中拥有至少一个虚函数,那么编译器就会构建出一个虚函数表(virtual method table)来指示这些函数的地址,假如继承该类的子类定义并实现了一个同名并具有同样函数签名(function siguature)的方法重写了基类中的方法,那么虚函数表会将该函数指向新的地址。此时多态性就体现出来了:当我们将基类的指针或引用指向子类的对象的时候,调用方法时,就会顺着虚函数表找到对应子类的方法而非基类的方法。
当然虚函数表的存在对于效率上会有一定的影响,首先构建虚函数表需要时间,根据虚函数表寻到到函数也需要时间。
因为这个原因如果没有继承的需要,一般不必在类中定义虚函数。但是对于继承来说,虚函数就变得很重要了,这不仅仅是实现多态性的一个重要标志,同时也是dynamic_cast转换能够进行的前提条件。
假如去掉上个例子中Stranger类析构函数前的virtual,那么语句
Children* child_r =dynamic_cast<Children*> (stranger_r);
在编译期就会直接报出错误,具体原因不是很清楚,我猜测可能是因为当类没有虚函数表的时候,dynamic_cast就不能用RTTI来确定类的具体类型,于是就直接不通过编译。
这不仅仅是没有继承关系的类之间的情况,如果基类或者子类没有任何虚函数(如果基类有虚函数表,子类当然是自动继承了该表),当他们作为dynamic_cast的源类型进行转换时,编译也会失败。
这种情况是有可能存在的,因为在设计的时候,我们可能不需要让子类重写任何基类的方法。但实际上,这是不合理的。导师在讲解多态性的时候,时刻强调了一点:如果要用继承,那么一定要让析构函数是虚函数;如果一个函数是虚函数,那么在子类中也要是虚函数。
总结:dynamic_cast 用于实现拥有虚函数的基类向子类的继承转换,以及子类之间的交叉转换。
4.reinterpret_cast
本来想写的,但是我下班了,所以有空再补充。