类型转换机制可以分为:隐式类型转换 和 显示类型转换(强制类型转换)

C中的类型转换:

  事情要从头说起,这个头就是C语言.我们已经习惯了使用C-like类型转换,因为它强大而且简单.

主要有一下两种形式:

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

C艹中的类型转换:

隐式类型转换比较常见,在混合类型表达式中经常发生.比如在表达式中存在short和int,那么就过会发生整型提升.四种强制类型转换操作符:static_cast、dynamic_cast、const_cast、reinterpret_cast。

1. static_cast与dynamic_cast:

  把这两个放在一起比较容易记忆,"一静一动".从字面上也可以看出,前者提供的是编译时期的静态类型检测,后者提供的是

运行时检测.

  • static_cast: 1)完成基础数据类型,2)同一个继承体系中类型的转换 3)任意类型与空指针类型void*之间的转换。
  • dynamic_cast:使用多态的场景,增加了一层对真实调用对象类型的检查
     char c  = ;
int *p = (int *)&c;
cout<<(char)*p<<endl;//'A'
*p = ;
int *q = static_cast<int *>(&c); //编译报错:error: invalid static_cast from type ‘char*’ to type ‘int*’

  在上面的例子中,Clike可以运行,然而修改过的*p如果使用,运行结果将会出现错误,而使用static_cast可以将错误在编译时期检查出,.

  在不同继承体系的自定义类型中:

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;
}; A *ptrA = new A();
C *ptrC = (C *)(ptrA);
ptrC->printC(); //"call printC() in class C"
//ptrC = static_cast<C*>(ptrA); //编译报错:error: invalid static_cast from type 'A*’ to type C*’

  上面A C是两个无关的类,然而使用Clike可以实现这种类型的强制转换,这是十分危险的! 使用static_cast可以将这种潜在的危险在编译器找出来.

  在同一继承体系中:

  upcast(向上转换即子类转成父类):没有问题.因为父类的行为都包含在子类中;

  downcast(向下转换):有可能会出现问题,编译时可能不会发现.

  一个类的行为和自身的类型相关.也就是一个A类型的指针总会优先调用自己A类内的函数,当然发生继承中的重写(虚继承等)例外.

#include <iostream>
#include <cstdio> using namespace std;
class A
{
public:
A():i(), j(){}
~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(), b() {}
~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();
A *ptrA = static_cast<B *>(ptrB);
ptrA -> printA();
ptrA -> printSum();
//打印结果:sum = 2
//在进行upcast的时候,指针指向的对象的行为与指针的类型相关。 ptrA = new A;
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 &>(b);
rA.printA();
rA.printSum();
//打印结果: sum = 2
//在进行upcast的时候,指针指向的对象的行为与引用类型相关. A a;
A &rA1 = a;
rA.printSum();
B &rB1 = static_cast<B &>(a);
rB1.printB();
   //打印结果:sum = 4
rB1.printSum();
//打印结果 :sum = 1.45863e-316
//在进行downcast的时候,其行为是“undefined”。 return ;
}

  这里其实很明显,在downcast转换的时候,会出现一些跟指针或者引用类型相关的函数调用,但是因为指针或者引用(父类)

没有定义这些行为,因为调用到了这些行为导致出现了未定义的行为.

  明显解决这个问题的办法就是,虚函数!如果声明A类中的printSum未 虚函数,那么子类B就会有一个虚表,虚表中的第一个函数就是printSum函数其实是

B类的该函数.所以,A类指针调用该函数就会调用B类中的该函数 显示结果sum= 4. 在未定义之前sum = 2(A类中的该函数).

  PS:引用类型必须被初始化,这是引用和指针类型的重要区别.

  总之,就是尽可能不要使用downcast也就是 使用子类的指针指向父类.

  感觉这里又不得不说,c++内存对象的对齐方式.所以 ,在另外一篇blog<c++内存的对齐方式>中理清楚这些问题.

dynamic_cast
1.dynamic_cast是在运行时检查的,用于在集成体系中进行安全的向下转换downcast(当然也可以向上转换,但没必要,因为可以用虚函数实现)

即:基类指针/引用 -> 派生类指针/引用

如果源和目标没有继承/被继承关系,编译器会报错!
2.dynamic_cast是4个转换中唯一的RTTI操作符,提供运行时类型检查。
3.dynamic_cast不是强制转换,而是带有某种”咨询“性质的,如果不能转换,返回NULL。这是强制转换做不到的。

4.源类中必须要有虚函数,保证多态,才能使用dynamic_cast<source>(expression)

static_cast

用法:static_cast < type-id > ( expression )

该运算符把expression转换为type-id类型,在编译时使用类型信息执行转换,在转换执行必要的检测(指针越界,类型检查),其操作数相对是安全的。

但没有运行时类型检查来保证转换的安全性。

reinterpret_cast

仅仅是复制n1的比特位到d_r, 没有进行必要的分析.interpret_cast是为了映射到一个完全不同类型\
的意思,这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄\
玄虚和其他目的,这是所有映射中最危险的。(这句话是C++编程思想中的原话

const_cast

去除const常量属性,使其可以修改

and

volatile属性的转换  易变类型<->不同类型.

Code:

#include <iostream>
#include <cstdio>
#include <string> using namespace std; class A {
public:
A(){};
int m_a;
}; class B {
public:
int m_b;
}; class C : public A, public B {}; int main()
{
const A a;
//a.num = 1;
const_cast<A&>(a).m_a = ;
//a.num = 3;编译不能通过,说明const_cast只能转换一次,不是永久脱离原有const属性
cout<<a.m_a<<endl;
int n = ;
double d_s = static_cast<double>(n);
double d_r = reinterpret_cast<double&>(n);
cout<<d_r<<endl;//4.24399e-314
//在进行计算以后, d_r包含无用值. 这是因为 reinterpret_cast\
仅仅是复制n1的比特位到d_r, 没有进行必要的分析.interpret_cast是为了映射到一个完全不同类型\
的意思,这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄\
玄虚和其他目的,这是所有映射中最危险的。(这句话是C++编程思想中的原话 C c;
printf("%p, %p, %p\n", &c, reinterpret_cast<B*>(&c), static_cast <B*>(&c));
//前两个的输出值是相同的,最后一个则会在原基础上偏移4个字节,这是因为static_cast计算了父子类指针转换的偏移量,\
并将之转换到正确的地址(c里面有m_a,m_b,转换为B*指针后指到m_b处),而reinterpret_cast却不会做这一层转换\
因此, 你需要谨慎使用 reinterpret_cast. return ;
}
#include <iostream>
#include <typeinfo>
#include <cstdio> using namespace std; class A{
public:
virtual void foo(){
cout<<"A foo"<<endl;
}
//虚函数的出现会带来动态机制 Class A 至少要有一个虚函数
void pp(){
cout<<"A pp"<<endl;
}
}; class B: public A{
public:
void foo(){
cout<<"B foo"<<endl;
}
void pp(){
cout<<"B PP"<<endl;
}
void functionB(){
cout<<"Excute FunctionB!"<<endl;
}
}; int main()
{
B b;
A *pa = &b;
pa->foo();
pa->pp();
//基类指针可以指向派生类,但是只能调用基类和派生类都存在的成员,也就是说不能调用派生类中新增的成员!
//pa->FunctionB();//error: 'class A' has no member named 'FunctionB'
if(dynamic_cast<B*>(pa) == NULL){
cout<<"NULL"<<endl;
}else{
cout<<typeid((dynamic_cast<B*>(pa))).name()<<endl;
dynamic_cast<B*>(pa)->foo();
dynamic_cast<B*>(pa)->pp();
dynamic_cast<B*>(pa)->functionB();
}
A aa;
//B *pb = &aa;派生类不能指向基类
B *pbNull = NULL;
pbNull->functionB();//fine
pbNull->pp();//fine
//pbNull->functionB(); crash!foo调用了虚函数,编译器需要根据对象的虚函数指针查找虚函数表,但为空,crash!
return ;
}

c++ 四种类型转换机制的更多相关文章

  1. C++语言中的四种类型转换

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

  2. 【C++】类型转换简述:四种类型转换方式的说明及应用

    本文主要简述在C++中四种类型转换的方式:static_cast.reniterpret_cast.const_cast和dynamic_cast. 在介绍C++类型转换方式之前,我们先来看看C语言的 ...

  3. C++ 四种类型转换

    在写代码中经常会有很多的隐式类型转换或显式类型转换. 对于隐式的类型转换主要是放生在赋值的时候,讲变量赋值给不同类型的变量的时候就会发生类型转换,如果是宽化转换(即从占字节少的类型向占字节多的类型转换 ...

  4. [转]C++中四种类型转换符的总结

    C++中四种类型转换符的总结 一.reinterpret_cast用法:reinpreter_cast<type-id> (expression)    reinterpret_cast操 ...

  5. 从零开始学C++之从C到C++(二):引用、内联函数inline、四种类型转换运算符

    一.引用 (1).引用是给一个变量起别名 定义引用的一般格式:类型  &引用名 = 变量名: 例如:int a=1; int  &b=a;// b是a的别名,因此a和b是同一个单元 注 ...

  6. c++ --> c++中四种类型转换方式

    c++中四种类型转换方式   c风格转换的格式很简单(TYPE)EXPRESSION,但是c风格的类型转换有不少缺点, 1)它可以在任意类型之间转换,比如你可以把一个指向const对象的指针转换成指向 ...

  7. 【转】C++四种类型转换方式

    C++四种类型转换方式 https://blog.csdn.net/lv_amelia/article/details/79483579 C风格的强制类型转换(Type Case)很简单,不管什么类型 ...

  8. 引用、数组引用与指针引用、内联函数inline、四种类型转换运算符

    一.引用 (1).引用是给一个变量起别名 定义引用的一般格式:类型  &引用名 = 变量名: 例如:int a=1;  int  &b=a;// b是a的别名,因此a和b是同一个单元 ...

  9. C++中四种类型转换以及const_cast是否能改变常量的问题

    we have four specific casting operators:dynamic_cast, reinterpret_cast, static_cast and const_cast. ...

随机推荐

  1. 手动模拟一个类似jquery的ajax请求

    var $ = { parms:function(obj){ var str = ''; for(var k in obj){ str +=k+'='+obj[k]+'&'; } str = ...

  2. java 日历计算农历和节假日的工具类

    背景 业务需求需要后端提供这样的接口,网上找了很多java代码例子,虽然功能实现了 但是不完善,特别是节日那一块儿.然后百度发现有这样的插件,但是信息也是java后端提供的非js 然后在开源js插件找 ...

  3. cookie & cookies

    cookie & cookies "use strict"; /** * * @author xgqfrms * @license MIT * @copyright xgq ...

  4. HDU 1253 三维数组的图上找最短路

    题目大意: 从三维空间的(0,0,0)出发到(a-1,b-1,c-1),每移动一个都要时间加一,计算最短时间 根据六个方向,开个bfs,像spfa那样计算最短路径就行了,但是要1200多ms,也不知道 ...

  5. Codeforces Round #260 (Div. 2) D

    D. A Lot of Games time limit per test 1 second memory limit per test 256 megabytes input standard in ...

  6. noip模拟赛 算

    [问题背景]zhx 帮他妹子做数学题.[问题描述]求: 如 N=3, M=3, 这个值为 1^1+1^2+1^3+2^1+2^2+2^3+3^1+3^2+3^3=56. [输入格式]仅一行, 包含两个 ...

  7. Spring @Conditional注解 详细讲解及示例

    版权声明:本文为博主原创文章,未经博主允许不得转载. https://blog.csdn.net/xcy1193068639/article/details/81491071 前言: @Conditi ...

  8. Linux 使用pwgen命令创建随机密码

    https://blog.csdn.net/fdipzone/article/details/73864598 http://www.netkou.com/?post=155

  9. Javascript MVC 学习笔记(三) 视图和模板

    模板 Javascript中模板的核心概念是,将包括模板变量的HTML片段和Javascript对象做合并.把模板变量替换为对象中的属性值. 书中讲到了几种库作为模板引擎,可是链接失效了.能够在这里下 ...

  10. HTML5权威指南之—第三章

    HTML页面上元素的焦点能够通过"tab"键在各个元素之间切换,使用"tabindex"属性能够改变默认的转移顺序 Tabindex为1的元素会首先被选中.然后 ...