c++类型转换

c语言
void Test ()
{
int i = 1;
// 隐式类型转换
double d = i;(4–8)
printf("%d, %.2f\n" , i, d);
int* p = &i;
// 显示的强制类型转换
int address = (int) p;相近类型支持类型转换,但是这个不相似
printf("%x, %d\n" , p, address);
}
强类型语言都设计类型转换,弱类型不同类型可以互相转换
相近类型支持类型转换
sizeI_t i=10;
while(i>=0){//死循环
cout<<i<<endl;
–i;
}
int i=10;
size_t pos=0;不行
while(i>=pos){//死循环,类型提升了提升成size_t,出现负数了
cout<<i<<endl;
–i;
}
size_t pos=5;可以
while(i>=pos){
cout<<i<<endl;
–i;
}
标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：
static_cast、reinterpret_cast、const_cast、dynamic_cast
static_cast:对应隐式类型转换:是相近类型的转换同c语言
double d=1.1111;
int i1=d;
int i2=static_cast (d);//可以看成static_cast模板类型d对象
reinterpret_cast:是不相关类型的转换reinterpret reinterpret reinterpret_cast
int p=reinterpret_cast<int>(i2);数字转指针
const int x=10;
const intcpx=&x;
int px=&x;不可以,权限放大
如果要用则用const_cast:去掉const属性
intpx=const_cast<int>(cpx);
px=20;
cout<<x<<endl;结果为10
cout<<px<<endl;结果为20
c/c++里面有优化,正常情况是不会修改,const都放在寄存器里了x始终是10,
volatile const int x=10;防止编译器过度优化
volatile const intcpx=&x;
intpx=const_cast<int>(cpx);
px=20;
cout<<x<<endl;结果为20
cout<<px<<endl;结果为20
防止编译器过度优化
const修饰的变量一般不能改变,但是在特定情况可以改变const_cast类型转换
typedef void ( FUNC)();
int DoSomething (int i)
{
cout<<“DoSomething” <<endl;
return 0;
}
FUNC f = reinterpret_cast< FUNC>(DoSomething );//强转void*
f();//(f)()
}
相近类型的转换涉及数据丢失,数据的截断和提升
dynamic_cast动态转换—>继承关系的转换
用于将一个父类对象的指针/引用转换为子类对象的指针或引用(动态转换)
向上转型：子类对象指针->父类指针/引用(不需要转换，赋值兼容规则,切片可以 完成) 向下转型：父类对象指针->子类指针/
引用(用dynamic_cast转型是安全的)
注意： 1. dynamic_cast只能用于含有虚函数的类 2. dynamic_cast会先检查是否能转换成功，能成功则转
换，不能则返回0
父类的指针转成子类的指针
A pa=new A;如果指向父类,会导致越界
B* pb=(B*)pa;错误
A* pa=new B;如果指向子类,
B* pb=(B*)pa;对
class a{
public:
virtual func(){}
protected:
int _a;
}
class b:public a
{
protected:
int _b;
}
int main(){
A* pa=new A;
B* pb=dynamic_cast<B*>(pa);//构造
cout<<pb<<endl;
A* pa1=new B;
B* pb1=(B*)pa1;
cout<<pb1<<endl;
}
识别指针到底指向父类还是子类,如果是指向父类转换不成功返回0
怎么实现?danamic_cast
template
class danamic_cast{
public:
danamic_cast
如果是构造函数无法控制返回值不行
}

函数实现
template<,class Pdirve,class base>
Pdirve danamic_cast(base* p){
if(){
return null;}
else{
return (Pdirve)p;
}
}
B* pb=dynamic_cast<B*>(pa);–实现
通过定义多态
class a{
public:
virtual func(){}
protected:
int _a;
}
class b:public a
{
protected:
int _b;
}
template<,class Pdirve,class base>
Pdirve danamic_cast(base* p){
//多态处理
if(p->is_base()){
return null;}
else{
return (Pdirve)p;
}
}
RTTI:运行时类型识别(danamic_cast,typeid())
不知道不知道pb2类型
cout<<typeid(pb2).name()<<endl
A3* pa1=new A3;
B3* pb1=my_dynamic_cast<B3*>(pa1);
cout<<pb1<<endl;//0
A3* pa2=new B3;
B3pb2=my_dynamic_cast<B3>(pa2);
cout<<pb2<<endl;//0x1536c40
cout<<typeid(pb2).name()<<endl;
}
116 //explicit关键字阻止经过转换构造函数进行的隐式转换的发生
class A4{
public:
explicit A4(int a){
cout<<“A4(int a)”<<endl;
}
A4(const A4&a){
cout<<“A(const A&a)”<<endl;
}
private:
int _a;
};
void test5(){
A a1(1);
//隐式转换-> A tmp(1);
//A a2(tmp);
A a2=1;
}