C++中的四中类型转换

const_cast<type_new>(expression)

取常性类型转换。

主要用于对变量的常量性转换，可以让非常量指针或者引用来指向常量。

//const_cast<new_type>(expression)
#include<iostream>
using namespace std;
class A
{
public:
	A(int data=10):ma(data){}
	int ma;
};
int main()
{
	const int b=10;
	const int* p=&b;
	//int *s=&b;//error
	int *s=const_cast<int*>(p);
	cout<<"*s="<<*s<<endl;

	const A a;
	cout<<"a.ma="<<a.ma<<endl;

	//A* pa=&a;//error C2440: “初始化”: 无法从“const A *”转换为“A *”
	A* pa=const_cast<A*>(&a);//ok
	cout<<"pa->ma="<<pa->ma<<endl;

	//A& ra=a;//error C2440: “初始化”: 无法从“const A”转换为“A &”
	A& ra=const_cast<A&>(a);//ok
	cout<<"ra.ma="<<ra.ma<<endl;
	return 0;
}

打印结果：

reinterpert_cast<net_type>(expression)

重新解释类型转换（interpret为转换的意思，re前缀表示重新）。

主要对二进制数据进行重新解释，并且不改变格式。

//reinterpret_cast<new_type>(expression)
#include<iostream>
using namespace std;
class B1
{
public:
	B1(int data=20):mb1(data){}
	int mb1;
};
class B2
{
public:
	B2(int data=30):mb2(data){}
	int mb2;
};
class D:public B1,public B2
{};
int main()
{
	int x=10;
	int *p=&x;
	double *s=reinterpret_cast<double*>(p);
	cout<<"p="<<p<<"   --------  "<<"*p="<<*p<<endl;
	cout<<"s="<<s<<"   --------  "<<"*s="<<*s<<endl;
	
	D d;
	B1* pb1=reinterpret_cast<B1*>(&d);//重新解释转换，地址不变
	B2* pb2=reinterpret_cast<B2*>(&d); 
	cout<<"&d="<<&d<<endl;
	cout<<"pb1="<<pb1<<"   --------  "<<"pb1->mb1="<<pb1->mb1<<endl;
	cout<<"pb2="<<pb2<<"   --------  "<<"pb2->mb2="<<pb2->mb2<<endl;
	
	return 0;
}

打印结果：

dynamic_cast<new_type>(expression)

动态类型转换。

向下安全性转换，主要用于继承并且有虚函数中，可以将“指向派生类的基类指针”转换成“指向派生类”或者“指向兄弟类”。

//dynamic_cast<new_type>(expression)
#include<iostream>
using namespace std;

class Base1
{
public:
	Base1(int data=10):mb1(data){}
	int mb1;
	virtual void show()
	{
		cout<<"Base1::show()"<<"------"<<"Base1::mb1="<<mb1<<endl;
	}
};
class Base2
{
public:
	Base2(int data=20):mb2(data){}
	int mb2;
	virtual void show()
	{
		cout<<"Base2::show()"<<"------"<<"Base2::mb2="<<mb2<<endl;
	}
	virtual void Print()
	{
		cout<<"Base2::Print()"<<endl;
	}
};
class Derive:public Base1,public Base2
{
public:
	Derive(int data=30):mb3(data){}
	int mb3;
	virtual void show()
	{
		cout<<"Derive::show()"<<"------"<<"Derive::mb3="<<mb3<<endl;
	}
	virtual void Print()
	{
		cout<<"Derive::Print()"<<endl;
	}
};
int main()
{
	Base1* pb1=new Derive;//基类的指针指向派生类对象
	pb1->show();
	
	//Derive* pd=pb1;//error C2440: “初始化”: 无法从“Base1 *”转换为“Derive *”
	Derive* pd=dynamic_cast<Derive*>(pb1);//将"基类指针指向派生类对象"转换成"指向派生类型的指针"
	pd->show();
	pd->Print();

	//Base2* pb1=pb1;//error C2440: “初始化”: 无法从“Base1 *”转换为“Base2 *”
	Base2* pb2=dynamic_cast<Base2*>(pb1);////将"基类指针指向派生类对象"转换成"指向兄弟类型的指针"
	pb2->show();
	pb2->Print();
	return 0;
}

打印：

static_cast<new_type>(expression)

静态类型转换。

相对于dynamic_cast比较，在继承关系中，不能让“基类指针指向派生类对象”转换为“指向兄弟类型的指针”。

//static_cast<new_type>(expression)
#include<iostream>
using namespace std;

class Base1
{
public:
	Base1(int data=10):mb1(data){}
	int mb1;
	virtual void show()
	{
		cout<<"Base1::show()"<<"------"<<"Base1::mb1="<<mb1<<endl;
	}
};
class Base2
{
public:
	Base2(int data=20):mb2(data){}
	int mb2;
	virtual void show()
	{
		cout<<"Base2::show()"<<"------"<<"Base2::mb2="<<mb2<<endl;
	}
	virtual void Print()
	{
		cout<<"Base2::Print()"<<endl;
	}
};
class Derive:public Base1,public Base2
{
public:
	Derive(int data=30):mb3(data){}
	int mb3;
	virtual void show()
	{
		cout<<"Derive::show()"<<"------"<<"Derive::mb3="<<mb3<<endl;
	}
	virtual void Print()
	{
		cout<<"Derive::Print()"<<endl;
	}
};
int main()
{

	Base1* pb1=new Derive;//基类的指针指向派生类对象
	pb1->show();
	
	Derive* pd=static_cast<Derive*>(pb1);//将"基类指针指向派生类对象"转换成"指向派生类型的指针"
	pd->show();
	pd->Print();

	//Base2* pb2=static_cast<Base2*>(pb1);////不能将"基类指针指向派生类对象"转换成"指向兄弟类型的指针"
	//pb2->show();
	//pb2->Print();

	return 0;
}

相对于reinterpret_cast比较，只进行类型的转换。

class B1
{
public:
	B1(int data=20):mb1(data){}
	int mb1;
};
class B2
{
public:
	B2(int data=30):mb2(data){}
	int mb2;
};
class D:public B1,public B2
{};
int main()
{
	int x=10;
	int *p=&x;

	//double *s=static_cast<double*>(p);//error
	//cout<<"p="<<p<<"   --------  "<<"*p="<<*p<<endl;
	//cout<<"s="<<s<<"   --------  "<<"*s="<<*s<<endl;

	D d;

	B1* sb1=static_cast<B1*>(&d);//静态转换，地址变
	B2* sb2=static_cast<B2*>(&d); 

	cout<<"&d="<<&d<<endl;
	cout<<"sb1="<<sb1<<"   --------  "<<"sb1->mb1="<<sb1->mb1<<endl;
	cout<<"sb2="<<sb2<<"   --------  "<<"sb2->mb2="<<sb2->mb2<<endl;
	return 0;
}

打印：