C++类型转换

C++类型转换#

静态转换：

​ 用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换

//指针
void test02() {
	Father* f = NULL;
	Son* s = NULL;
	//向下转换 不安全
	Son* s1 = static_cast<Son*> (f);
	//向上转换 安全
	Father* f1 = static_cast<Father*> (s);
	//没有 继承关系的类之间的指针不能转换
	//other* o = static_cast<other*>(s);
} 

//引用
void test02() {
	Father f;
	Son s;
	Father &ref_f = f;
	Son& ref_s = s;
	
	static_cast<Father&>(ref_s);
	static_cast<Son&>(ref_f);
} 

​ 用于基本数据类型之间的转换，如把int转换成char，把char转换成int。这种转换的安全性也要开发人员来保证

//基础类型转换
void test02() {
	char a = 'a';
	//char - > double
	double d = static_cast<double> (a);
	// double d = (double)a;
}

动态转换：

l 不支持基础类型的转换

char a = 'a';
//不支持基础类型转换
dynamic_cast<double>(a); //error

l ynamic_cast主要用于类层次间的上行转换和下行转换；

l 在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的；

l 在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全；

void test05() {
	Father* f = NULL;
	Son* s = NULL;
	//向下转换 不安全 会检测
	Son* s1 = dynamic_cast<Son*> (f); //error
	//向上转换 安全
	Father* f1 = dynamic_cast<Father*> (s);
}

l 发生多态时候，动态转换就可以

class Father {
public:
	virtual void func() {}
};
class Son :public Father {
	virtual void func() {} //重写父类虚函数
};
void test05() {
    //发生多态时候，可以向下转换
	Father* f = new Son;
	Son* s = dynamic_cast<Son*> (f);
}

常量转换

l 常量指针被转化成非常量指针，并且仍然指向原来的对象；

void test() {
	const int* p = nullptr;
	//const --> 不带const的
	int* newptr = const_cast<int*> (p);
}

void test01() {
	int* p = nullptr;
	//不带const的--> const
	const int* newptr = const_cast<const int*> (p);
}

l 常量引用被转换成非常量引用，并且仍然指向原来的对象；

void test05() {
	int num = 5;
	const int& refnum1 = num;
	//常量引用 ---> 非常量引用
	int& newrefnum1 = const_cast<int&> (refnum1);
}

void test02() {
	int num = 5;
	int& refnum1 = num;
	//常量引用 ---> 非常量引用
	const int& newrefnum1 = const_cast<cosnt int&> (refnum1);
}

重新解释转换

这是最不安全的一种转换机制，最有可能出问题。

主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针.

class other {};
class Father {
public:
	virtual void func() {}
};
class Son :public Father {
	virtual void func() {}
};

//重新解释转换
void test02() {
    //基础类型
	int num = 5;
	int* p = reinterpret_cast<int*> (num);
    //其他类类型
    Father *f = NULL;
	other* p = reinterpret_cast<other*> (f);
}