C++中类型的强制转换

C++中类型的强制转换分为以下四种：

1、static_cast<T>(expr);

2、reinterpret_cast<T>(expr);

3、const_cast<T>(expr);

4、dynamic_cast<T>(expr);

其中前三种为编译时检查，最后一种为运行时检查。

static_cast<T>(expr)：用于基本类型之间的转换，但不能用于基本类型指针之间的转换，用于有继承关系的类之间的转换，用于有继承关系类指针之间的转换。

reinterpret_cast<T>(expr):用于指针类型之间的强制转换，用于指针和整数之间的转换。

const_cast<T>(expr):去掉变量的const属性。

dynamic_cast<T>(expr):主要用于类层次之间的转换，必须要有多态（继承，虚函数重写）。

 

static_cast<T>(expr);

#include<iostream>
using namespace std;
class A
{};
class B : public A
{};
int main()
{
	int a=1;
	double b;
	a=static_cast<int>(b);      //可以用于基本类型之间的转换
	/*int *pa;
	char *pc;
	pa=static_cast<int>(pc);    //不能用于基本类型之间指针的转换*/
	A aa;
	B bb;
	aa=static_cast<A>(bb);      //可以用于有继承关系之间类的转换
	//bb=static_cast<B>(aa);   不能将基类赋值给派生类
	A *pa1;
	B *pb1;
	pa1=static_cast<A *>(pb1);
	pb1=static_cast<B *>(pa1);  //可以用于有继承关系之间类指针之间的转换
	return 0;
}

reinterpret_cast<T>(expr);

#include<iostream>
using namespace std;
int main()
{
	int a=1;
	char b='a';
	int *pa=&a;
	char *pb=&b;
	pa=reinterpret_cast<int *>(pb);
	pb=reinterpret_cast<char *>(pa);
	return 0;
}

const_cast<T>(expr);

#include<iostream>
using namespace std;
int main()
{
	const int a=1;
	int *pa = const_cast<int *>(&a);
	const int &b=1;       //用常量给常引用赋值
	int &c=const_cast<int &>(b);
	c=2;
	cout << b << endl;  //常引用时值可以改变
	const int d=1;      //常量
	int &e=const_cast<int &>(d);
	e=2;
	cout << d << endl;  //值不可以被改变
	return 0;
}

dynamic_cast<T>(expr);

#include<iostream>
using namespace std;
class A
{
private:
	int m_a;
public:
	virtual void show()
	{
		
	}
};
class B : public A
{
private:
	int m_b;
public:
	virtual void show()
	{
		
	}
};
int main()
{
	A a;
	B b;
	A *pa=&a;
	B *pb=&b;
	//pa=dynamic_cast<A *>(pb);  
	pa=dynamic_cast<A *>(&b);        //主要用于类层次之间的转换，必须具有多态性，动态检查。
	pb=dynamic_cast<B *>(&a);
	return 0;
}