C++四种基本类型转换

1.static_cast

用法: static_cast (expression)
说明:该运算符把expression转换为typen_name类型，static_cast在编译时使用类型信息执行转换,在转换执行必要的检测(诸如指针越界计算,类型检查等);但没有运行时类型检查来保证转换的安全性。
枚举是收到限制的整型，取值范围收到限制，枚举不能++
静态转换两者类型要兼容，而且不能去常性，但是可以加常性
无类型指针可以转成任意类型

基本类型转换

enum WeekType { sun = 0, mon = 1, ture = 2, wed = 3 };
int main()
{
	int a = 10;
	char ch = 'a';
	double dx = 12.23;
	//a = static_cast (dx);
	ch = static_cast<char>(dx);
	WeekType x = sun;
	//x++;//error
	a = x;
	//x = a;//error
	x = static_cast<WeekType>(a);

	return 0;
}

指针转换的限制

int main(){
	int a = 10;
	int* p = &a;
	int* s = static_cast<int*>(&a); 
	int* s = nullptr;
	const int* cp = static_cast<const int*>(&a);
	//char* chp = static_cast(&a);//error
	//s = static_cast(cp);//error;静态转换类型必须一致
	s = const_cast<int*>(cp);

}

左值转右值

int main() {
	int a = 10;
	int &x= a;//左值

	//int&& rx = a;//error
	int&& rx = static_cast<int&&>(a);
	return 0;
}

rx x 都是a的别名

上下行转换

class Object {
private:
int value; public:
	Object(int x = 0) : value(x) {
		cout << "Create Object: " << endl;
	}
	~Object() {
		cout << "Destory 0bject" << endl;
	}

};
class Base : public Object {
private: int num; public:
	Base(int x = 0) : Object(x + 10), num(x) {
		cout << "Create Base " << endl;
	}
	 ~Base() {
		cout << "Destroy Base" << endl;
	}

};
int main() {
	Object* op = nullptr;
	Base* bp = nullptr;
	Base base;
	Object obj;
	op = &obj;
	bp = &base;

	op = bp;
	//bp = op;//error

	op = static_cast<Object*>(&base);
	bp = static_cast<Base*>(&obj);
	return 0;
}

bp = static_cast(&obj);这里虽然可以编译，但是逻辑上是错误的，内存填充的是默认值，bp = op;//error这里直接就无法编译
上行转换安全，下行转换不安全

2.const_cast

用法:const_cast (expression)
可以适用基本类型，也可以用在自己设计的类型
说明:该运算符用来修改类型的const或volatile属性。除了const或volatile修饰之外，typename和expression的类型是一样的。

去常性

特点:
1)用于去除变量的只读属性
2)强制转换的目标类型必须是指针或引用

int main() {
	int a = 10;
	const int* ap = &a;
	const int& ra = a;

	//int* ip = ap;
	//int& r = ra; 编译不通过

	int* ip = const_cast<int*>(ap);
	int& r = const_cast<int&>(ra);
}

const 编译时的替换

class Int {
private:
	int value;
public:
	Int(int x = 0) :value(x) {
		cout << "Create Int" << endl;
	}
	~Int() {	}
	void SetValue(int x) {
		value = x;
	}
	int GetValue() const { return value; }

};
int main() {
	const int ca = 10;
	int* cap = const_cast<int*>(&ca);
	*cap = 20;
	cout << ca << endl;

	const Int a(10);
	//Int* p = &a;//error
	cout << a.GetValue() << endl;;
	Int* p = const_cast<Int*>(&a);
	p->SetValue(100);
	cout << a.GetValue() << endl;

	Int& aa = const_cast<Int&>(a);
	aa.SetValue(200);
	cout << a.GetValue() << endl;
}

由于ca是常整型，但是在编译的时候，ca已经被替换成了10，虽然它确实是变成了20，但是打印的还是10
而Int就不一样了，是常对象，去常性后，就可以修改

3.reinterpret_cast

用法: reinpreter_cast (expression)
说明: type_name必须是一个指针、引用、算术类型、函数指针或者成员指针。它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针。类似C语言的强转。
特点:
不适用基本数据类型之间的转换
用于指针类型间的强制转换

指针类型间的强制转换

int main() {
	int a = 0x61626364;
	//char* p = &a;//error
	char* p = reinterpret_cast<char*>(&a);
	cout << *p << endl;
	p += 1;
	cout << *p << endl;
	p += 1;
	cout << *p << endl;
	p += 1;
	cout << *p << endl;

	return 0;
}

p+1的能力跟指向的类型无关，根自己的类型有关

class Object {
private:
	int value;
public:
	Object(int x = 0) : value(x) { }
	~Object() {}
	int& Value() { return value; }
	const int& Value() const { return value; }
};

int main() {
	Object obj(10);
	int* p = reinterpret_cast<int*>(&obj);
	int& a = reinterpret_cast<int&>(obj);
	cout << obj.Value() << endl;
	*p = 100;
	cout << obj.Value() << endl;
	a = 200;
	cout << obj.Value() << endl;
	
	return 0;
}

对象和对象中的数据成员value是同一个地址

4 .dynamic_cast

语法: dynamic_cast ( expression )
说明: dynamic_cast操作符，它允许在运行时刻进行类型转换,从而使程序能够在一个类层次结构中安全地转换类型,把基类指针转换成派生类指针,或把指向基类的左值转换成派生类的引用。
必须是公有继承，基类要有虚函数。
特点:
1.与C++支持的其他强制转换不同的是，dynamic_cast是在运行时执行的类型转换。
⒉.如果针对指针类型的dynamic_cast失败,则dynamic_cast的结果是nullptr。
3.如果针对引用类型的dynamic_cast失败，则dynamic_cast会抛出一个异常。
4.在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的。
5.在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

初识动态转换

class Object {
private:
	int value;
public:
	Object(int x=0):value(x){}
	~Object(){}
	virtual void func() { cout << "virtual Object func" << endl; }
	void fun() { cout << "Object fun"<<endl; }
};
class Base :public Object {
private:
	int num;
public:

	Base(int x=0):Object(x),num(x+10){ }
	~Base(){}
	virtual void func(){ cout << "virtual Base func" << endl; }
	void fun() { cout << "Base fun" << endl; }
};

int main() {
	Object* op1 = nullptr, * op2 = nullptr;
	Object obj(10);
	Base* bp = nullptr;
	Base base(10);
	op1 = &base;
	op2 = &obj;

	op1->fun();
	op1->func();
	op2->fun();
	op2->func();

	bp = dynamic_cast<Base*>(op1);
	bp->fun();
	bp->func();
	return 0;
}

总结：
Object* op1 = nullptr, op1 = &base; op1在用静态函数时，他就是Object*， 但是有虚函数时，就是Base*，通过动态转换Base* bp = nullptr;， bp = dynamic_cast(op1); op1在用静态函数时，和虚函数时，都就是Base*

验证多态才能实现动态转换

int main() {
	Object* op1 = nullptr, * op2 = nullptr;
	Object obj(10);
	Base* bp = nullptr;
	Base base(10);
	op1 = &base;
	op2 = &obj;
	//指针类型信息
	cout << typeid(op1).name() << endl;
	cout << typeid(op2).name() << endl;
	cout << typeid(*op1).name() << endl;
	cout << typeid(*op2).name() << endl;
	
	op1->fun();
	op1->func();
	op2->fun();
	op2->func();

	//op1指向&base，可以动态转换
	bp = dynamic_cast<Base*>(op1);
	bp->fun();
	bp->func();

	//op1指向&obj，不可以动态转换
	bp = dynamic_cast<Base*>(op2);
	if (bp == nullptr) {
		cout << "bp==nullptr" << endl;
	}
	else bp->func();
	return 0;
}

typeid(*op1).name() 能知道指针所指之物是存储了类型识别信息

反向 多态

这里下行转换，就不行

int main() {
	
	Object obj(10);
	Base* bp = nullptr;
	Base base(10);
	Object* op1 = &base;
	Object* op2 = &obj;
	//Base* bp1 = &obj;//err
	Base* bp1 = static_cast<Base*>(&obj);//作用就是编译通过 逻辑上不行
	Base* bp2 = &base;
	bp1->fun();
	bp1->func();
	bp2->fun();
	bp2->func();

	return 0;
}