做2手车网站需要多少钱,织梦txt网站地图制作,粤icp备案号查询网官网,网络服务合同范本免费隐式类型转换是安全的#xff0c;显式类型转换是有风险的#xff0c;C语言之所以增加强制类型转换的语法#xff0c;就是为了强调风险#xff0c;让程序员意识到自己在做什么。但是#xff0c;这种强调风险的方式还是比较粗放#xff0c;粒度比较大#xff0c;它并没有表…隐式类型转换是安全的显式类型转换是有风险的C语言之所以增加强制类型转换的语法就是为了强调风险让程序员意识到自己在做什么。但是这种强调风险的方式还是比较粗放粒度比较大它并没有表明存在什么风险风险程度如何。 再者C风格的强制类型转换统一使用( )而( )在代码中随处可见所以也不利于使用文本检索工具例如 Windows 下的 CtrlF、Linux 下的 grep 命令、Mac 下的 CommandF定位关键代码。为了使潜在风险更加细化使问题追溯更加方便使书写格式更加规范C 对类型转换进行了分类并新增了四个关键字来予以支持它们分别是 这四个关键字的语法格式都是一样的具体为 xxx_castnewType(data) newType 是要转换成的新类型data 是被转换的数据。例如老式的C风格的 double 转 int 的写法为 double scores 95.5;int n (int)scores;
C 新风格的写法为 double scores 95.5;int n static_castint(scores);
static_cast 关键字 static_cast 只能用于良性转换这样的转换风险较低一般不会发生什么意外例如 原有的自动类型转换例如 short 转 int、int 转 double、const 转非 const、向上转型等 void 指针和具体类型指针之间的转换例如void *转int *、char *转void *等 有转换构造函数或者类型转换函数的类与其它类型之间的转换例如 double 转 Complex调用转换构造函数、Complex 转 double调用类型转换函数。
需要注意的是static_cast 不能用于无关类型之间的转换因为这些转换都是有风险的例如 两个具体类型指针之间的转换例如int *转double *、Student *转int *等。不同类型的数据存储格式不一样长度也不一样用 A 类型的指针指向 B 类型的数据后会按照 A 类型的方式来处理数据如果是读取操作可能会得到一堆没有意义的值如果是写入操作可能会使 B 类型的数据遭到破坏当再次以 B 类型的方式读取数据时会得到一堆没有意义的值。 int 和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的因为该地址上的内存可能没有分配也可能没有读写权限恰好是可用内存反而是小概率事件。
static_cast 也不能用来去掉表达式的 const 修饰和 volatile 修饰。换句话说不能将 const/volatile 类型转换为非 const/volatile 类型。static_cast 是“静态转换”的意思也就是在编译期间转换转换失败的话会抛出一个编译错误。下面的代码演示了 static_cast 的正确用法和错误用法 #include iostream#include cstdlibusing 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_castlong(m); //宽转换没有信息丢失char ch static_castchar(m); //窄转换可能会丢失信息int *p1 static_castint*( malloc(10 * sizeof(int)) ); //将void指针转换为具体类型指针void *p2 static_castvoid*(p1); //将具体类型指针转换为void指针double real static_castdouble(c); //调用类型转换函数//下面的用法是错误的float *p3 static_castfloat*(p1); //不能在两个具体类型的指针之间进行转换p3 static_castfloat*(0X2DF9); //不能将整数转换为指针类型return 0;}
const_cast 关键字
const_cast 比较好理解它用来去掉表达式的 const 修饰或 volatile 修饰。换句话说const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。 下面我们以 const 为例来说明 const_cast 的用法 #include iostreamusing namespace std;int main(){const int n 100;int *p const_castint*(n);*p 234;coutn nendl;cout*p *pendl;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 行代码被修改成了下面的形式 coutn 100endl; 这样以来即使程序在运行期间修改 n 的值也不会影响 cout 语句了。更多关于 const 的内容请猛击《C中的const又玩出了新花样》。使用 const_cast 进行强制类型转换可以突破 C/C 的常数限制修改常数的值因此有一定的危险性但是程序员如果这样做的话基本上会意识到这个问题因此也还有一定的安全性。
reinterpret_cast 关键字
reinterpret 是“重新解释”的意思顾名思义reinterpret_cast 这种转换仅仅是对二进制位的重新解释不会借助已有的转换规则对数据进行调整非常简单粗暴所以风险很高。 reinterpret_cast 可以认为是 static_cast 的一种补充一些 static_cast 不能完成的转换就可以用 reinterpret_cast 来完成例如两个具体类型指针之间的转换、int 和指针之间的转换有些编译器只允许 int 转指针不允许反过来。 下面的代码代码演示了 reinterpret_cast 的使用 #include iostreamusing namespace std;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_castfloat*(str);cout*p1endl;//将 int 转换为 int*int *p reinterpret_castint*(100);//将 A* 转换为 int*p reinterpret_castint*(new A(25, 96));cout*pendl;return 0;}
运行结果3.0262e2925可以想象用一个 float 指针来操作一个 char 数组是一件多么荒诞和危险的事情这样的转换方式不到万不得已的时候不要使用。将A*转换为int*使用指针直接访问 private 成员刺穿了一个类的封装性更好的办法是让类提供 get/set 函数间接地访问成员变量。
dynamic_cast 关键字
dynamic_cast 用于在类的继承层次之间进行类型转换它既允许向上转型Upcasting也允许向下转型Downcasting。向上转型是无条件的不会进行任何检测所以都能成功向下转型的前提必须是安全的要借助 RTTI 进行检测所有只有一部分能成功。 dynamic_cast 与 static_cast 是相对的dynamic_cast 是“动态转换”的意思static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换这就要求基类必须包含虚函数static_cast 在编译期间完成类型转换能够更加及时地发现错误。 dynamic_cast 的语法格式为 dynamic_cast newType (expression) newType 和 expression 必须同时是指针类型或者引用类型。换句话说dynamic_cast 只能转换指针类型和引用类型其它类型int、double、数组、类、结构体等都不行。对于指针如果转换失败将返回 NULL对于引用如果转换失败将抛出std::bad_cast异常。
1) 向上转型Upcasting
向上转型时只要待转换的两个类型之间存在继承关系并且基类包含了虚函数这些信息在编译期间就能确定就一定能转换成功。因为向上转型始终是安全的所以 dynamic_cast 不会进行任何运行期间的检查这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。 「向上转型时不执行运行期检测」虽然提高了效率但也留下了安全隐患请看下面的代码 #include iostream#include iomanipusing namespace std;class Base{public:Base(int a 0): m_a(a){ }int get_a() const{ return m_a; }virtual void func() const { }protected:int m_a;};class Derived: public Base{public:Derived(int a 0, int b 0): Base(a), m_b(b){ }int get_b() const { return m_b; }private:int m_b;};int main(){//情况①Derived *pd1 new Derived(35, 78);Base *pb1 dynamic_castDerived*(pd1);coutpd1 pd1, pb1 pb1endl;coutpb1-get_a()endl;pb1-func();//情况②int n 100;Derived *pd2 reinterpret_castDerived*(n);Base *pb2 dynamic_castBase*(pd2);coutpd2 pd2, pb2 pb2endl;coutpb2-get_a()endl; //输出一个垃圾值pb2-func(); //内存错误return 0;}
情况①是正确的没有任何问题。对于情况②pd 指向的是整型变量 n并没有指向一个 Derived 类的对象在使用 dynamic_cast 进行类型转换时也没有检查这一点而是将 pd 的值直接赋给了 pb这里并不需要调整偏移量最终导致 pb 也指向了 n。因为 pb 指向的不是一个对象所以get_a()得不到 m_a 的值实际上得到的是一个垃圾值pb2-func()也得不到 func() 函数的正确地址。 pb2-func()得不到 func() 的正确地址的原因在于pb2 指向的是一个假的“对象”它没有虚函数表也没有虚函数表指针而 func() 是虚函数必须到虚函数表中才能找到它的地址。 2) 向下转型Downcasting
向下转型是有风险的dynamic_cast 会借助 RTTI 信息进行检测确定安全的才能转换成功否则就转换失败。那么哪些向下转型是安全地呢哪些又是不安全的呢下面我们通过一个例子来演示 #include iostreamusing namespace std;class A{public:virtual void func() const { coutClass Aendl; }private:int m_a;};class B: public A{public:virtual void func() const { coutClass Bendl; }private:int m_b;};class C: public B{public:virtual void func() const { coutClass Cendl; }private:int m_c;};class D: public C{public:virtual void func() const { coutClass Dendl; }private:int m_d;};int main(){A *pa new A();B *pb;C *pc;//情况①pb dynamic_castB*(pa); //向下转型失败if(pb NULL){coutDowncasting failed: A* to B*endl;}else{coutDowncasting successfully: A* to B*endl;pb - func();}pc dynamic_castC*(pa); //向下转型失败if(pc NULL){coutDowncasting failed: A* to C*endl;}else{coutDowncasting successfully: A* to C*endl;pc - func();}cout-------------------------endl;//情况②pa new D(); //向上转型都是允许的pb dynamic_castB*(pa); //向下转型成功if(pb NULL){coutDowncasting failed: A* to B*endl;}else{coutDowncasting successfully: A* to B*endl;pb - func();}pc dynamic_castC*(pa); //向下转型成功if(pc NULL){coutDowncasting failed: A* to C*endl;}else{coutDowncasting successfully: A* to C*endl;pc - func();}return 0;}
运行结果
Downcasting failed: A* to B*
Downcasting failed: A* to C*
-------------------------
Downcasting successfully: A* to B*
ClassD
Downcasting successfully: A* to C*
Class D
这段代码中类的继承顺序为A -- B -- C -- D。pa 是A*类型的指针当 pa 指向 A 类型的对象时向下转型失败pa 不能转换为B*或C*类型。当 pa 指向 D 类型的对象时向下转型成功pa 可以转换为B*或C*类型。同样都是向下转型为什么 pa 指向的对象不同转换的结果就大相径庭呢
在《C RTTI机制下的对象内存模型透彻》一节中我们讲到了有虚函数存在时对象的真实内存模型并且也了解到每个类都会在内存中保存一份类型信息编译器会将存在继承关系的类的类型信息使用指针“连接”起来从而形成一个继承链Inheritance Chain也就是如下图所示的样子 当使用 dynamic_cast 对指针进行类型转换时程序会先找到该指针指向的对象再根据对象找到当前类指针指向的对象所属的类的类型信息并从此节点开始沿着继承链向上遍历如果找到了要转化的目标类型那么说明这种转换是安全的就能够转换成功如果没有找到要转换的目标类型那么说明这种转换存在较大的风险就不能转换。
对于本例中的情况①pa 指向 A 类对象根据该对象找到的就是 A 的类型信息当程序从这个节点开始向上遍历时发现 A 的上方没有要转换的 B 类型或 C 类型实际上 A 的上方没有任何类型了所以就转换败了。对于情况②pa 指向 D 类对象根据该对象找到的就是 D 的类型信息程序从这个节点向上遍历的过程中发现了 C 类型和 B 类型所以就转换成功了。
总起来说dynamic_cast 会在程序运行过程中遍历继承链如果途中遇到了要转换的目标类型那么就能够转换成功如果直到继承链的顶点最顶层的基类还没有遇到要转换的目标类型那么就转换失败。对于同一个指针例如 pa它指向的对象不同会导致遍历继承链的起点不一样途中能够匹配到的类型也不一样所以相同的类型转换产生了不同的结果。从表面上看起来 dynamic_cast 确实能够向下转型本例也很好地证明了这一点B 和 C 都是 A 的派生类我们成功地将 pa 从 A 类型指针转换成了 B 和 C 类型指针。
但是从本质上讲dynamic_cast 还是只允许向上转型因为它只会向上遍历继承链。造成这种假象的根本原因在于派生类对象可以用任何一个基类的指针指向它这样做始终是安全的。本例中的情况②pa 指向的对象是 D 类型的pa、pb、pc 都是 D 的基类的指针所以它们都可以指向 D 类型的对象dynamic_cast 只是让不同的基类指针指向同一个派生类对象罢了。
