C++【类型转换】-创新互联
- 一、C语言的类型转换
- 二、C++的强制类型转换
- 1.static_cast静态转换
- 2.reinterpret_cast重新诠释
- 3.const_cast
- 小总结
- 4.dynamic_cast动态转换
在C语言中,如果赋值运算符左右两侧类型不同,或者形参与实参类型不匹配,或者返回值类型与接收返回值类型不一致时,就需要发生类型转化,C语言中总共有两种形式的类型转换:隐式类型转换和显式类型转换。
- 隐式类型转化:编译器在编译阶段自动进行,能转就转,不能转就编译失败
- 显式类型转化:需要用户自己处理
using namespace std;
void Test ()
{int i = 1;
// 隐式类型转换
double d = i;
printf("%d, %.2f\n" , i, d);
int* p = &i;
// 显示的强制类型转换
int address =(int)p;
printf("%x, %d\n" , p, address);
}
int main() {Test();
return 0;
}
隐式类型转换:意义相近的类型
char int short float double…整形家族
(它们都是用来表示数据大小的,区别就是存储的数据范围不同)
强制类型转换:意义不相近
比方说int和指针的意义不想近,所以不可以进行隐式类型转换。
但是它们的值转换后有意义。
虽然指针表示一个地址(虚拟地址,都是一个一个的编号),所以可以转。
但如果是一个学生类的话,我们不能将其转换成整型
隐式类型转换的潜在问题
//在pos位置插入一个字符
void Insert(size_t pos,char ch)
{size_t _size=10;
//我们需要把数据向后挪动
size_t end=_size-1;
//即使我们将size_t写成了int,依旧会进入死循环
//因为这里的符号运算也会发生整形类型提升
//也就是隐式类型提升,让我们的end变成一个无符号整形
while(end>=pos)
{// _str[end+1]=_str[end];
--end;
}
}
int main() {Insert(5,'a');
//会陷入死循环,因为我们的end是一个无符号整型,所以根本就不可能为负数,所以会一直进行插入操作。
Insert(0,'a');
return 0;
}
C风格的转换格式很简单,但是有不少缺点的:
- 隐式类型转化有些情况下可能会出问题:比如数据精度丢失
- 显式类型转换将所有情况混合在一起,代码不够清晰
因此C++提出了自己的类型转化风格,注意因为C++要兼容C语言,所以C++中还可以使用C语言的转化风格。
标准C++为了加强类型转换的可视性,引入了四种命名的强制类型转换操作符:
static_cast、reinterpret_cast、const_cast、dynamic_cast
static_cast用于非多态类型的转换(静态转换),编译器隐式执行的任何类型转换都可用static_cast,但它不能用于两个不相关的类型进行转换(用于意义相近的类型:整型,浮点)
int main()
{double d = 12.34;
int a = static_cast(d);
cout<
那如果不是相近的类型能不能转换呢?
不可以的!
int main()
{int*p=&a;
int address=static_cast(p);
return 0;
}
2.reinterpret_cast重新诠释reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释,用于将一种类型转换为另一种不同的类型
(可以用于不同的数据类型进行转换)
typedef void (* FUNC)();
int DoSomething (int i)
{cout<<"DoSomething"<//
// reinterpret_cast可以编译器以FUNC的定义方式去看待DoSomething函数
// 所以非常的BUG,下面转换函数指针的代码是不可移植的,所以不建议这样用
// C++不保证所有的函数指针都被一样的使用,所以这样用有时会产生不确定的结果
//
FUNC f = reinterpret_cast< FUNC>(DoSomething );
f();
}
int main()
{Test();
}
3.const_castconst_cast最常用的用途就是删除变量的const属性,方便赋值
int main()
{const int a = 2;
int* p = const_cast< int*>(&a );
*p = 3;
cout<
在C++中,这里的常量为常变量,可以修改,但是不能直接进行修改,我们可以通过上面的形式进行修改。
为什么是2和3,不是3和3
编译器对于const类型是有优化的,因为编译器认为const类型的变量不会被修改,那每次从内存中取的话,就会非常慢,那C++就将上面的a直接加载到一个寄存器当中,每次访问的时候(读取数据)直接去这个寄存器中读取数据就可以了。虽然你的内存中的数据被改成3了,但是寄存器中的数据并没有被修改。
为什么const_cast需要单独拿出来?
因为const_cast很危险,所以我们将其单独拿出来
int main()
{//告诉编译器不要优化了,每次都去内存中取我们的值
volatile const int a = 2;
int* p = const_cast< int*>(&a );
*p = 3;
cout<
int main()
{//告诉编译器不要优化了,每次都去内存中取我们的值
volatile const int a = 2;
// int* p = const_cast< int*>(&a );
//C语言的也是可以使用的
int *p=(int*)&a;
*p = 3;
cout<
小总结1.兼容C隐式类型转换和强制类型转换
2.期望不要用了,期望你通用规范的C++显式的强制类型转换
3.static_cast对应隐式类型转换
reinterpret_cast、const_cast对应的是强制类型转换
dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型:子类对象指针/引用->父类指针/引用(不需要转换,赋值兼容规则)
向下转型:父类对象指针/引用->子类指针/引用(用dynamic_cast转型是安全的)
注意:
- dynamic_cast只能用于==含有虚函数的类 ==
- dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回0
子类给父类是向上转换,是C++的一个特例,是赋值兼容的,虽然两个对象的类型不一样,但是所有的类型转换都会产生临时变量
int main()
{int i=0;
//将i转给临时变量,然后再将这个值给d
double d=i;
//临时变量具有常性,所以我们不能直接将i赋值给rd
// double& rd=i;
//加上const就可以了
//c语言的写法
const double& rd1=i;
//C++的写法
const double& rd2=static_cast(i);
}
class A
{public:
int _a=0;
};
class B:public A{public:
int _b=0;
};
int main()
{B bb;
//进行切片,然后转换。
A aa1=bb;
A& ra1=bb;
}
父类是不允许转换成子类的,无论是我们上面说的C++中的四个转换中的任何一个都是不可以的。
指针也引用要允许转换!
为什么指针和引用要允许转换(为什么允许指针或者对象向下转换呢?)
因为父类的指针有可能指向父类对象,也有可能指向子类对象。
如果你是一个父类的指针,你原本只能查看四个字节的大小,但是你如果现在能查看8个字节的大小,那么,这就是越界访问了。
(你的父类的指针指向一个子类的对象,但是你如果访问到了子类的部分,你就是越界访问,这是不被允许的)
但是你用dynamic_cast去转换,那么你就是安全的
class A
{public :
virtual void f(){}
int _a;
};
class B : public A
{int _b;
};
//A*的指针有可能指向父类,也有可能指向子类,
void fun (A* pa)
{//如果pa指向子类,那么可以转换,重新转换成子类,这种方式是安全的
//如果pa指向父类,那么不能转换,转换表达式为nullptr
// dynamic_cast会先检查是否能转换成功,能成功则转换,不能则返回
B* pb1 = dynamic_cast(pa);
cout<<"pb1:"<A a;
B b;
fun(&a);
fun(&b);
fun(nullptr);
return 0;
}
如果是static_cast或者c语言的转换的话,可以转换,但是其实已经越界访问了
class A
{public :
virtual void f(){}
int _a;
};
class B : public A
{int _b;
};
//A*的指针有可能指向父类,也有可能指向子类,
void fun (A* pa)
{//如果pa指向子类,那么可以转换,重新转换成子类,这种方式是安全的
//如果pa指向父类,那么不能转换,转换表达式为nullptr
B* pb1 = static_cast(pa);
B* pb2=(B*)pa;
cout<<"pb1:"<A a;
B b;
fun(&a);
fun(&b);
fun(nullptr);
return 0;
}
在多继承中的使用情况
class A1
{public :
virtual void f(){}
int _a1;
};
class A2
{public :
virtual void f(){}
int _a2;
};
class B : public A1,public A2
{public:
int _b;
};
int main ()
{B bb;
A1* ptr1=&bb;
A2* ptr2=&bb;
cout<(ptr1);
B* pb6=dynamic_cast(ptr2);
cout<
它会把我们的指针偏移给修改回去。都会重新指向子类对象的起始位置,不会因为两个不同的父类的指针指向子类的对象而产生不同。
强制类型转换能够将我们的类型转换给规范起来,我们最好去遵守这些规范。
RAII
初始化一个对象。将资源交给这个对象进行管理
(资源获得即初始化)
RTTI(Run_time Type identification)
运行时类型识别
1.typeid运算符,拿到对象的类型的字符串,帮助我们观察
2.dynamic_cast运算符,用来识别父类的指针是指向父类的对象还是指向子类的对象、
3.decltype
推导一个对象类型,可以用来定义另一个对象。
你是否还在寻找稳定的海外服务器提供商?创新互联www.cdcxhl.cn海外机房具备T级流量清洗系统配攻击溯源,准确流量调度确保服务器高可用性,企业级服务器适合批量采购,新人活动首月15元起,快前往官网查看详情吧
文章标题:C++【类型转换】-创新互联
本文URL:http://pwwzsj.com/article/ccccie.html