『C++』类型转换

C语言中的强制类型转换

void test(){
	int i = 10;
	// 隐式类型转换
	double d = i;
	printf("%d, %.2f\n", i, d);

	int* pi = &i;
	// 显式强制类型转换
	int address = (int)pi;

	printf("%x, %d\n", pi, address);
}

C语言中类型转换的缺陷：

• 转换的可视性比较差，所有的转换形式都是以一种相同形式书写，难以跟踪错误的转换。
  再来看一个例子：

#include <iostream>
using namespace std;

int main(){
	int i = 10;
	size_t pos = 0;

	while (i >= pos){
		cout << i << endl;
		--i;
	}
	
	return 0;
}

结果是死循环，因为发生了隐式类型转换，int被隐式转换为size_t类型，导致死循环。

C++强制类型转换

标准C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符：

static_cast
reinterpret_cast
const_cast
dynamic_cast

static_cast

static_cast用于非多态类型的转换（静态转换），编译器隐式执行的任何类型转换都可用static_cast，但它不能用于两个不相关的类型进行转换。

#include <iostream>
using namespace std;

void StaticCast(){
	double d = 66.88;

	int i = static_cast<int>(d);

	cout << i << endl;
}

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

再来看一个例子：

#include <iostream>
using namespace std;

int main(){
	int i = 10;

	int* pi = static_cast<int*>(i);

	return 0;
}

从上述可以看出，static_cast只能用于相近类型的转换，不能用于两个不相关类型的转换。如果想要将一个类型转换为另一个不相关的类型，可以使用reinterpret_cast关键字。

reinterpret_cast

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

#include <iostream>
using namespace std;

typedef void(*func)();

int doSomething(int i){
	cout << "do something" << endl;

	return 0;
}

int main(){

	func f = reinterpret_cast<func>(doSomething);

	f();
	
	return 0;
}

从上面可以看出，我们可以不传参去调用doSomething函数，那么函数doSomething的形参i的值是多少呢？我们将代码略作修改，来看一下。

#include <iostream>
using namespace std;

typedef void(*func)();

int doSomething(int i){
	cout << "do something" << endl;
	cout << i << endl;

	return 0;
}

int main(){
	func f = reinterpret_cast<func>(doSomething);
	f();

	return 0;
}

实际上，这个形参i是一个随机值。形参没有接收到实参传的值，所以形参相当于没有被初始化，所以是一个随机值。全局变量不初始化为0，局部变量未初始化为随机值。
reinterpret_cast可以让编译器以func的方式去看待doSomething函数，下面转换函数指针的代码是不可移植的，所以不建议这样用。C++不保证所有的函数指针都被一样的使用，所以这样用有时会产生不确定的结果。

const_cast

const_cast最常用的用途就是删除变量的const属性，方便赋值。
下面来看一段代码：

#include <iostream>
using namespace std;

int main(){
	const int i = 10;

	const int* cpi = &i;

	int* pi = const_cast<int*>(cpi);

	*pi = 20;

	cout << i << endl;

	return 0;
}

上述代码，逻辑比较简单，就是定义了一个const常量，然后使用const_cast去掉了其const属性，使其可以被修改。也就是说，上述代码运行结果应该是20，我们来看一下运行结果。

结果是10，这是为什么呢，代码编译没有问题啊，也就是说const_cast已经去掉了其const属性，为什么结果没有改变呢？
我们将代码略作修改，打印一下*pi的值。

可以看到，*pi的值被改变了，而i的值还是10，为什么会出现这种情况，我们再来打印一下它们的地址。

可以看到，二者代表的也是同一块空间，为什么结果会不一样呢，不卖关子了，这是因为，编译器做了优化，将const类型变量放到了寄存器中，所以虽然变量被修改了，但是编译器不会从内存中读取数据，而是直接从寄存器读取数据，所以出现了这种情况。
可以使用volatile关键字来避免这种情况，每次访问变量的时候都重新从内存中读取，而不是使用寄存器中的备份。

dynamic_cast

dynamic_cast用于将一个父类对象的指针/引用转换为子类对象的指针或引用（动态转换）。
向上转型：子类对象指针->父类指针/引用（不需要转换，赋值兼容即可）。
向下转型：父类对象指针->子类指针/引用（用dynamic_cast转型是安全的）。
注意：

1. dynamic_cast只能用于含有虚函数的类。
2. dynamic_cast会先检查是否能转换成功，能成功则转换，不能则返回0。

来看下面的代码。

#include <iostream>
using namespace std;

class A{
protected:
	int _a;
};

class B : public A{
protected:
	int _b;
};

int main(){

	A* pa1 = new A;
	B* pb1 = (B*)pa1;

	A* pa2 = new B;
	B* pb2 = (B*)pa2;

	return 0;
}

上述代码两个转换都会成功，但是这不是我们想要的，我们想要的是前一个不能转换成功而后一个可以转换成功，C语言原有的转换方式显然不能够满足我们的需求，所以需要使用dynamic_cast来实现。
将上述代码进行修改：

#include <iostream>
using namespace std;

class A{
public:
	virtual void hehe(){

	}

protected:
	int _a;
};

class B : public A{
public:
	virtual void hehe(){

	}

protected:
	int _b;
};

int main(){

	A* pa1 = new A;
	B* pb1 = dynamic_cast<B*>(pa1);
	cout << pb1 << endl;

	A* pa2 = new B;
	B* pb2 = dynamic_cast<B*>(pa2);
	cout << pb2 << endl;

	return 0;
}

从上述运行结果可以看出，可以满足我们的需求，如果父类指针指向的是子类就允许其转换为子类指针。如果父类指针指向的是父类就不允许其转换为子类指针，将其置为nullptr。
如何实现dynamic_cast？
方法一：

class A{
public:
	virtual void hehe(){

	}

	virtual bool isBase(){
		return true;
	}

protected:
	int _a;
};

class B : public A{
public:
	virtual void hehe(){

	}

	virtual bool isBase(){
		return false;
	}

protected:
	int _b;
};

template<class Child, class Parent>
Child my_dynamic_cast(Parent* p){
	if (p->isBase()){
		return nullptr;
	}
	else{
		return (Child)p;
	}
}

int main(){
	A* pa1 = new A;
	B* pb1 = my_dynamic_cast<B*>(pa1);
	cout << pb1 << endl;

	A* pa2 = new B;
	B* pb2 = my_dynamic_cast<B*>(pa2);
	cout << pb2 << endl;

	return 0;
}

方法二：

注意：
强制类型转换关闭或挂起了正常的类型检查，每次使用强制类型转换前，都需要仔细考虑是否还有其他不同的方法达到同一目的，如果非强制类型转换不可，则应限制强制转换值的作用域，以减少发生错误的机会。
强烈建议：避免使用强制类型转换。

explict

explic关键字阻止经过转换构造函数进行的隐式转换的发生。

#include <iostream>
using namespace std;

class A{
public:
	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;
	
	return 0;
}

使用explicit关键字就可以阻止这种隐式类型转换。

#include <iostream>
using namespace std;

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

为什么C++需要四种类型转换

C风格的转换格式很简单，但是有不少缺点：

1. 隐式类型转换有些情况下可能会出问题。
2. 显式类型转换将所有情况混合在一起，代码不够清晰。

RTTI

RTTI：Run-time Type identification的简称，即：运行时类型识别。
C++通过以下方式来支持RTTI：

1. typeid运算符。
2. dynamic_cast运算符。

#include <iostream>
using namespace std;

class A{
private:
	int _a;
};

class D : public A{
private:
	int _d;
};

int main(){

	A a;
	cout << typeid(a).name() << endl;

	int b;
	cout << typeid(b).name() << endl;

	void* c = nullptr;
	cout << typeid(c).name() << endl;

	D d;
	cout << typeid(d).name() << endl;

	char* e = "hello, world!";
	cout << typeid(e).name() << endl;

	long long f;
	cout << typeid(f).name() << endl;

	double g;
	cout << typeid(g).name() << endl;

	return 0;
}