C++基础之数据类型转换

类型转换的由来

类型转换是程序开发过程中常见的现象，大致可以分为低风险的数据类型转换和高风险的数据类型转换

• 低风险：int,float,double等基础数据类型的转换
• 高风险：基类派生类之间的指针转换

int main(){
	float test_float = 6.03;
	int   test_int_1 = int(test_float);
	int   test_int_2 = (int)test_float;

	cout << " test_float:" << test_float << " test_int_1:" << test_int_1 
		<< " test_int_2:" << test_int_2 << endl;
    // test_float:6.03 test_int_1:6 test_int_2:6
}

在C++ 11中引入了强制转换运算符

• static_cast 用于非多态类型的转换
• dynamic_cast 用于多态类型的转换。
• const_cast 用于删除const和volatile__unaligned属性
• reinterpret_cast 用于对位进行简单重新解释

MSDN . 强制转换运算符

隐式转换发生在从小->大的转换中

static_cast

• 用于非多态类型的转换
• 通常用于转换数值数据类型（如 float -> int ,可以理解成常见的基础类型转换）
• 把空指针转换成目标类型的空指针或把任何类型的表达式转为void类型
• 派生类转化为基类安全（向上转换），基类转化为派生类不安全（向下转换，派生类可能有基类不存在的字段或方法）

dynamic_cast

• 用于多态类型的转换
• 运行时类型检查
• 基类必须要有虚函数，
• 对无法确定的指针的转换会返回nullptr
• 对于下行转换，dynamic_cast是安全的（当类型不一致时，会返回nullptr，而static_cast是不安全的,转换回来的是错误意义的指针，可能会非法访问内存）
• 适用于指针或引用
• 可以在整个类层次结构中移动指针，包括向上转换、向下转换

const_cast

• 用于删除 const、volatile 和 __unaligned 特性
• 转换后的非常量指针or引用，仍然指向原来的对象
• 除常量性是一个危险的动作，尽量避免使用
  如将 volatile int 类型转换为 int 类型

reinterpret_cast

• 用于对位进行简单重新解释
• 类似于C语言显示强制转换，在编译阶段直接转换、强制赋值，可能会有风险。
• 允许将任意类型指针转换为其他类型指针类型（如 float* 到 char* 之类的转换，其本身并不安全）。
• 依赖具体的平台，可移植性差，不到万不得已，请别用

#include <iostream>
#include <thread>
#include <string>
using namespace std;
class People {
public:
	People(){};
	virtual ~People(){};
	virtual void OutputName() { 
		cout << __FUNCTION__ << " " << name << endl; 
	};

private:
	std::string name = "People";
};
class Student : public People{
public:
	Student(){};
	~Student(){};
	virtual void OutputName(){
		cout << __FUNCTION__ << " " << name << endl;
	};
	void StudentStudy() {
	}

private:
	std::string name = "Student";
};

class Teacher : public People {
public:
	Teacher(){};
	~Teacher(){};
	virtual void OutputName() {
		cout << __FUNCTION__ << " " << name << endl; 
	};

private:
	std::string name = "Teacher";
};


int main()
{
	People* p = new People();
	Student* s = new Student();
	Teacher* t = new Teacher();
	People*  pt = new Student();//基类指针指向派生类对象
	p->OutputName();
	s->OutputName();
	t->OutputName();
	pt->OutputName();
	cout << "======================================" << endl;
	People* p_1 = s;
	People* p_2 = dynamic_cast<People*>(s);
	p_1->OutputName();//Student::OutputName Student
	p_2->OutputName();//Student::OutputName Student
	cout << "======================================" << endl;
	Student* s_1 = (Student*)p;
	Student* s_2 = dynamic_cast<Student*>(p);
	Student* s_3 = dynamic_cast<Student*>(pt);
	Teacher* t_1 = dynamic_cast<Teacher*>(p);
	s_1->OutputName();//People::OutputName People
	if (s_2) {//nullptr
		cout << "s_2 ptr =";
		s_2->OutputName();	
	}
	if (s_3) {
		cout << "s_3 ptr =";
		s_3->OutputName();//Student::OutputName Student
	}
	if (t_1) {//nullptr
		cout << "t_1 ptr =";
		t_1->OutputName();
	}
	cout << "======================================" << endl;
	return 0;
}