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);
}