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;
}

打印：