#include <iostream>

using namespace std;

C++类型转换

• static_cast 普遍情况
• const_cast 去常量
• dynamic_cast 子类类型转为父类类型
• reinterpret_cast 函数指针转型，不具备移植性

原始类型转换，所有情况都是一种写法，可读性不高，有可能有潜在的风险

static_cast

void* func(int type){	
	switch (type){
	case 1:	{
				int i = 9;
				return &i;
	}
	case 2:	{
				int a = 'X';
				return &a;
	}
	default:{
				return NULL;
	}

	}	
}

void func2(char* c_p){
	cout << *c_p << endl;
}

void main(){	
	//int i = 0;
	//自动转换
	//double d = i;
	//double d = 9.5;
	//int i = d;

	//int i = 8;
	//double d = 9.5;
	//i = static_cast<int>(d);
	
	//void* -> char*
	//char* c_p = (char*)func(2);
	//char* c_p = static_cast<char*>(func(2));

	//C++ 意图明显
	func2(static_cast<char*>(func(2)));
	//C
	func2((char*)(func(2)));
	
	system("pause");
}

const_cast 去常量

void func(const char c[]){
	//c[1] = 'a';
	//通过指针间接赋值
	//其他人并不知道，这次转型是为了去常量
	//char* c_p = (char*)c;
	//c_p[1] = 'X';
	//提高了可读性
	char* c_p = const_cast<char*>(c);
	c_p[1] = 'Y';

	cout << c << endl;
}

void main(){
	char c[] = "hello";
	func(c);

	system("pause");
}

dynamic_cast 子类类型转为父类类型

class Person{
public:
	virtual void print(){
		cout << "人" << endl;
	}
};

class Man : public Person{
public:
	void print(){
		cout << "男人" << endl;
	}

	void chasing(){
		cout << "泡妞" << endl;
	}
};


class Woman : public Person{
public:
	void print(){
		cout << "女人" << endl;
	}

	void carebaby(){
		cout << "生孩子" << endl;
	}
};

void func(Person* obj){	

	//调用子类的特有的函数，转为实际类型
	//并不知道转型失败
	//Man* m = (Man*)obj;
	//m->print();

	//转型失败，返回NULL
	Man* m = dynamic_cast<Man*>(obj);	
	if (m != NULL){
		m->chasing();
	}

	Woman* w = dynamic_cast<Woman*>(obj);
	if (w != NULL){
		w->carebaby();
	}
}

void main(){
	
	//Woman w1;
	//Person *p1 = &w1;

	//func(p1);

	Woman w1;
	Woman* w_p = &w1;
	

	system("pause");
}

reinterpret_cast 函数指针转型，不具备移植性

不具备移植性：某些编译器可能不支持。
reinterpret_cast的最常用用途是转换“函数指针”类型。假设有一个数组存储的都是函数指针，有特定的类型：

void func1(){
	cout << "func1" << endl;
}

char* func2(){
	cout << "func2" << endl;
	return "abc";
}

typedef void(*f_p)();

void main(){
	//函数指针数组
	f_p f_array[6];
	//赋值
	f_array[0] = func1;

	//C方式
	//f_array[1] = (f_p)(func2);
	//C++方式
	f_array[1] = reinterpret_cast<f_p>(func2);

	f_array[1]();

	system("pause");
}

typedef void(*FuncPtr)(); //FuncPtr是个指针，指向某个函数，这个函数返回的是void（函数指针）