引入

C语言中的类型转换

C语言和C++都是强类型语言，如果赋值运算符左右两侧变量的类型不同，或形参与实参的类型不匹配，或返回值类型与接收返回值的变量类型不一致，那么就需要进行类型转换。

ps:强类型语言

• 强类型语言也称为强类型定义语言。是一种总是强制类型定义的语言，要求变量的使用要严格符合定义，所有变量都必须先定义后使用。
• java、.NET、C/C++等都是强制类型定义的。也就是说，一旦一个变量被指定了某个数据类型，如果不经过强制转换，那么它就永远是这个数据类型了。

例如你有一个整数，如果不显式地进行转换，你不能将其视为一个字符串。

与其相对应的是弱类型语言：数据类型可以被忽略的语言。它与强类型定义语言相反, 一个变量可以赋不同数据类型的值。

C语言中有两种形式的类型转换，分别是隐式类型转换和显式类型转换：

• 隐式类型转换：编译器在编译阶段自动进行，能转就转，不能转就编译失败。
• 显式类型转换：需要用户自己处理，以(指定类型)变量的方式进行类型转换。

需要注意的是，只有相近类型之间才能发生隐式类型转换，比如int和double表示的都是数值，只不过它们表示的范围和精度不同。而指针类型表示的是地址编号，因此整型和指针类型之间不会进行隐式类型转换，如果需要转换则只能进行显式类型转换。
例：

int main()
{
	//隐式类型转换
	int i = 1;
	double d = i;
	cout << i << endl;
	cout << d << endl;

	//显式类型转换
	int* p = &i;
	int address = (int)p;
	cout << p << endl;
	cout << address << endl;
	return 0;
}

C风格的转换格式虽然很简单，但也有很多缺点：

• 隐式类型转换在某些情况下可能会出问题，比如数据精度丢失。
• 显式类型转换将所有情况混合在一起，转换的可视性比较差。

因此C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符，分别是static_cast、reinterpret_cast、const_cast和dynamic_cast。

C++的强制类型转换

static_cast

static_cast用于相近类型之间的转换，编译器隐式执行的任何类型转换都可用static_cast，但它不能用于两个不相关类型之间转换。比如：

int main()
{
	double d = 2.34;
	//相近类型转换
	int a = static_cast<int>(d);
	cout << a << endl;
	
	//不相干类型转换
	int* p = static_cast<int*>(a);//error
	cout << *p << endl;
	return 0;
}

reinterpret_cat

reinterpret_cast操作符通常为操作数的位模式提供较低层次的重新解释，用于将一种类型转换为另一种不同的类型。比如：

int main()
{
	double d = 2.34;
	//相近类型转换
	int a = static_cast<int>(d);
	cout << a << endl;
	
	//int* p = static_cast<int*>(a);//error
	//cout << *p << endl;
	
	//不相干类型转换(重新解释)
	int b=10;
	int *c=&b;
	int* p = reinterpret_cast<int*>(c);
	cout << p << endl;//10
	return 0;
	  
}

reinterpret_cast还有一个非常bug的用法，比如在下面的代码中将带参带返回值的函数指针转换成了无参无返回值的函数指针，并且还可以用转换后函数指针调用这个函数。

typedef void (*FUNC)();
int DoSomething(int i)
{
	cout << "DoSomething" << endl << i << endl;
	return 0;
}
void Test1()
{
	//
	// reinterpret_cast可以编译器以FUNC的定义方式去看待DoSomething函数
	// 所以非常的BUG，下面转换函数指针的代码是不可移植的，所以不建议这样用
	// C++不保证所有的函数指针都被一样的使用，所以这样用有时会产生不确定的结果
	//
	FUNC f = reinterpret_cast<FUNC>(DoSomething);
	f();
}

int main()
{
	Test1();
	return 0;
}

用转换后的函数指针调用该函数时没有传入参数，因此这里打印出参数i的值是一个随机值。

const_cast

const_cast用于删除变量的const属性，转换后就可以对const变量的值进行修改。比如：

int main()
{
	const int a = 2;
	int* p = const_cast<int*>(&a);
	*p = 3;
	cout << *p << endl; //3
	return 0;
}

我们可以看到const_cast删除了变量a的地址的const属性，这时就可以通过p这个指针来修改变量a的值，对p指针解引用就可以访问a的值了。

---

但是这里有个奇怪的现象：如果我们直接对a的值进行打印，会发现a的值依旧是2，这是为什么？

解释：

由于编译器认为const修饰的变量是不会被修改的，因此会将const修饰的变量存放到寄存器当中，当需要读取const变量时就会直接从寄存器中进行读取，而我们修改的实际上是内存中的a的值，因此最终打印出a的值是未修改之前的值。

如果不想让编译器将const变量优化到寄存器当中，可以用volatile关键字对const变量进行修饰，这时当要读取这个const变量时编译器就会从内存中进行读取，即保持了该变量在内存中的可见性。

---

dynamic_cast

dynamic_cast用于将父类的指针（或引用）转换成子类的指针（或引用）,即向下转型。

向上转型与向下转型

• 向上转型： 子类的指针（或引用）→ 父类的指针（或引用）。
• 向下转型： 父类的指针（或引用）→ 子类的指针（或引用）。

ps:

注：从图中可以看出，派生类不仅有自己的方法和属性，同时它还包括从父类继承来的方法和属性。当我们从派生类向基类转换时(我们所说的切割/切片)，不管用传统的c语言还是c++转换方式都可以百分百转换成功。但是可怕是向下转换类型，也就是我们从基类向派生类转换，当我们采用传统的C语言和c++转换时，就会出现意想不到的情况，因为基类并没有派生类的属性和方法，进行转换就会出现安全问题。

---

向下转型的安全问题

向下转型又分为两种情况：

• 如果父类的指针（或引用）指向的是一个父类对象，那么将其转换为子类的指针（或引用）是不安全的，因为转换后可能会访问到子类的资源，而这个资源是父类对象所没有的。
• 如果父类的指针（或引用）指向的是一个子类对象，那么将其转换为子类的指针（或引用）则是安全的。

使用C风格的强制类型转换进行向下转型是不安全的，因为此时无论父类的指针（或引用）指向的是父类对象还是子类对象都会直接进行强制转换，不会为你区分是哪种情况，因此如果父类的指针（或引用）指向的是一个父类对象，那么将其转换为子类的指针（或引用）是不安全的，因为转换后可能会访问到子类的资源，而这个资源是父类对象所没有的。

而使用dynamic_cast进行向下转型则是安全的，它会为你区分这两种情况：如果父类的指针（或引用）指向的是子类对象那么dynamic_cast会转换成功，但如果父类的指针（或引用）指向的是父类对象那么dynamic_cast会转换失败并返回一个空指针。

举例：

class A
{
public:
	virtual void f()
	{}
};
class B : public A
{};
void func(A* pa)//pa为父类的指针
{
	B* pb1 = (B*)pa;               //不安全
	B* pb2 = dynamic_cast<B*>(pa); //安全

	cout << "pb1: " << pb1 << endl;
	cout << "pb2: " << pb2 << endl;
}
int main()
{
	A a;
	B b;
	func(&a);//&a指向父类的对象
	func(&b);//&b指向子类的对象
	return 0;
}

上述代码中，如果传入func函数的是子类对象的地址，那么在转换后pb1和pb2都会有对应的地址，但如果传入func函数的是父类对象的地址，那么转换后pb1会有对应的地址，而pb2则是一个空指针。

说明一下： dynamic_cast只能用于含有虚函数的类，因为运行时类型检查需要运行时的类型信息，而这个信息是存储在虚函数表中的，只有定义了虚函数的类才有虚函数表。

explicit

explicit用来修饰构造函数，从而禁止单参数构造函数的隐式转换。比如：

class A
{
public:
	explicit A(int a)
	{
		cout << "A(int a)" << endl;
	}
	A(const A& a)
	{
		cout << "A(const A& a)" << endl;
	}
private:
	int _a;
};
int main()
{
	A a1(1);
	//A a2 = 1; //error
	return 0;
}

在语法上，代码中的A a2 = 1等价于以下两句代码：

A tmp(1);  //先构造
A a2(tmp); //再拷贝构造

所以在早期的编译器中，当编译器遇到A a2 = 1这句代码时，会先构造一个临时对象，再用这个临时对象拷贝构造a2。但是现在的编译器已经做了优化，当遇到A a2 = 1这句代码时，会直接按照A a2(1)的方式进行处理，这也叫做隐式类型转换。

但对于单参数的自定义类型来说，A a2 = 1这种代码的可读性不是很好，因此可以用explicit修饰单参数的构造函数，从而禁止单参数构造函数的隐式转换。

4种类型转换的应用场景

• static_cast用于相近类型的类型之间的转换，编译器隐式执行的任何类型转换都可用static_cast。
• reinterpret_cast用于两个不相关类型之间的转换。
• const_cast用于删除变量的const属性，方便赋值。
• dynamic_cast用于安全的将父类的指针（或引用）转换成子类的指针（或引用）。

RTTI

RTTI（Run-Time Type Identification）就是运行时类型识别。

C++通过以下几种方式来支持RTTI：

• typeid：在运行时识别出一个对象的类型。
• dynamic_cast：在运行时识别出一个父类的指针（或引用）指向的是父类对象还是子类对象。
• decltype：在运行时推演出一个表达式或函数返回值的类型。

---

The end!