C++笔记1.类型转换

隐式转换

不需要用户干预，编译器私下进行的类型转换行为。（很多时候用户可能都不知道发生了哪些转换）
C++隐式转换原则：

• 基本数据类型的转换以低精度到高精度，保证精度不丢失。
• 自定义对象：子类对象可隐式转换为弗雷对象。

int a=3;
double b=4.5;
double c=a+b;      //a将被自动转换为double类型

禁止隐式转换：explicit

c++ 中的 explicit 关键字只能用于修饰只有一个参数的类构造函数，禁止隐式调用类内的单参数构造函数。

• 该关键字只能用来修饰类内部的构造函数；
• 禁止隐式调用拷贝构造函数；
• 禁止类对象之间的隐式转换；

显示转换

C强制类型转换：

double a=2.0;
int b=(int) a;    //可能会丢失精度

C++强制类型转换

const_cast

去掉常量的底层const属性

• 常量指针被转换为非常量的指针，仍然指向原来的对象，可以修改指向对象的值。
• 常量引用被转换非常量的引用，可以仍然指向原来的对象，可以修改引用的值。

const char str[]="hello";
char* c=const_cast<char*>(str);
strcpy(c,"world");
cout<<str<<" "<<c<<endl;
// world world

如果对象本身是常量，使用const_cast再写变量，则没有改变对象的值。

const int val=1;
int* aa=cosnt_cast<int*>(&val);
*aa=2;
cout<<val<<" "<<aa<<endl;
// 1 2 (没有改变const对象的值）

static_cast

任何具有明确定义的类型转换，只要不包含底层const，都可以使用static_cast。
只能用于良性转换，这样的转换风险较低。

• 完成基础数据类型转换
• 同一个继承体系中类型的转换
• 任意类型与空指针类型void*之间的转换。

static_cast 是“静态转换”的意思，也就是在编译期间转换，只会再编译时检查。如果编译器检测到强制转换完全不兼容的类型，则static_cast会返回错误。但是，编译器无法分辨此转换在运行时是否安全。
注意：
static_cast 不能用于无关类型（例如int和自定义类型）之间的转换，因为这些转换都是有风险的。

• 两个具体类型指针之间的转换
• int 和指针之间的转换

char a='A';
int x=static_cast<int>(a);
// 65

dynamic_cast

• 转换的目标类型必须是类的指针、类的引用或者void *，用于将基类的指针或引用更安全地转换成派生类的指针或引用(比static_cast更安全）。
• 既允许向上转型，也允许向下转型。向上转型是无条件的，不会进行任何检测，因为类型兼容规则；但是向下转型的前提必须是安全的，要借助 RTTI 进行检测，检测符合条件后才能转换。
• 对于指针，如果转换失败将返回 NULL；对于引用，如果转换失败将抛出std::bad_cast异常。

dynamic_cast 与 static_cast 是相对的，dynamic_cast 是“动态转换”的意思，static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。

向上转型：
只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。
向上转型时不执行运行期检测，虽然提高了效率，但也留下了安全隐患。

class Base{
public:
Base(int a = 0): m_a(a){ }
int get_a() const{ return m_a; }
virtual void func() const { }
protected:
int m_a;
};
 
class Derived: public Base{
public:
Derived(int a = 0, int b = 0): Base(a), m_b(b){ }
int get_b() const { return m_b; }
private:
int m_b;
};
 
int main(){
//情况①
Derived *pd1 = new Derived(35, 78);
Base *pb1 = dynamic_cast<Derived*>(pd1);
cout<<"pd1 = "<<pd1<<", pb1 = "<<pb1<<endl;
cout<<pb1->get_a()<<endl;
pb1->func();
 
//情况②
int n = 100;
Derived *pd2 = reinterpret_cast<Derived*>(&n);
Base *pb2 = dynamic_cast<Base*>(pd2);
cout<<"pd2 = "<<pd2<<", pb2 = "<<pb2<<endl;
cout<<pb2->get_a()<<endl; //输出一个垃圾值
pb2->func(); //内存错误

return 0;
}

情况①是正确的，没有任何问题。对于情况②，pd 指向的是整型变量 n，并没有指向一个 Derived 类的对象，在使用 dynamic_cast 进行类型转换时也没有检查这一点，而是将 pd 的值直接赋给了 pb（这里并不需要调整偏移量），最终导致 pb 也指向了 n。因为 pb 指向的不是一个对象，所以get_a()得不到 m_a 的值（实际上得到的是一个垃圾值），pb2->func()也得不到 func() 函数的正确地址。

向下转型：
有风险，dynamic_cast 会借助 RTTI 信息进行检测，确定安全的才能转换成功，否则就转换失败。

class A{
public:
virtual void func() const { cout<<"Class A"<<endl; }
private:
int m_a;
};
 
class B: public A{
public:
virtual void func() const { cout<<"Class B"<<endl; }
private:
int m_b;
};
 
class C: public B{
public:
virtual void func() const { cout<<"Class C"<<endl; }
private:
int m_c;
};
 
class D: public C{
public:
virtual void func() const { cout<<"Class D"<<endl; }
private:
int m_d;
};
 
int main(){
A *pa = new A();
B *pb;
C *pc;
 
//情况①
pb = dynamic_cast<B*>(pa); //向下转型失败
if(pb == NULL){
cout<<"Downcasting failed: A* to B*"<<endl;
}else{
cout<<"Downcasting successfully: A* to B*"<<endl;
pb -> func();
}
pc = dynamic_cast<C*>(pa); //向下转型失败
if(pc == NULL){
cout<<"Downcasting failed: A* to C*"<<endl;
}else{
cout<<"Downcasting successfully: A* to C*"<<endl;
pc -> func();
}
 
cout<<"-------------------------"<<endl;
 
//情况②
pa = new D(); //向上转型都是允许的
pb = dynamic_cast<B*>(pa); //向下转型成功
if(pb == NULL){
cout<<"Downcasting failed: A* to B*"<<endl;
}else{
cout<<"Downcasting successfully: A* to B*"<<endl;
pb -> func();
}
pc = dynamic_cast<C*>(pa); //向下转型成功
if(pc == NULL){
cout<<"Downcasting failed: A* to C*"<<endl;
}else{
cout<<"Downcasting successfully: A* to C*"<<endl;
pc -> func();
}
 
return 0;
}
/*运行结果：
Downcasting failed: A* to B*
Downcasting failed: A* to C*
-------------------------
Downcasting successfully: A* to B*
Class D
Downcasting successfully: A* to C*
Class D
*/

这段代码中类的继承顺序为：A --> B --> C --> D。pa 是A类型的指针，当 pa 指向 A 类型的对象时，向下转型失败，pa 不能转换为B或C*类型。

编译器会将存在继承关系的类的类型信息使用指针“连接”起来，从而形成一个继承链.

当使用 dynamic_cast 对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。

从表面上看起来 dynamic_cast 确实能够向下转型，本例也很好地证明了这一点：B 和 C 都是 A 的派生类，我们成功地将 pa 从 A 类型指针转换成了 B 和 C 类型指针。但是从本质上讲，dynamic_cast 还是只允许向上转型，因为它只会向上遍历继承链。造成这种假象的根本原因在于，派生类对象可以用任何一个基类的指针指向它，这样做始终是安全的。本例中的情况②，pa 指向的对象是 D 类型的，pa、pb、pc 都是 D 的基类的指针，所以它们都可以指向 D 类型的对象，dynamic_cast 只是让不同的基类指针指向同一个派生类对象罢了。

reinterpret_cast

可以用于任意类型的指针之间的转换，对转换的结果不做任何保证。（危险，比较少用）

reinterpret_cast 可以认为是 static_cast 的一种补充，但是reinterpret_cast更加底层。一些 static_cast 不能完成的转换，就可以用 reinterpret_cast 来完成，例如两个具体类型指针之间的转换、int 和指针之间的转换（有些编译器只允许 int 转指针，不允许反过来）。

int i;
char* p="hello";
i=reinterpret_cast(p);
//p由char类型的指针转换为int类型的指针。

char str[]="world";
float *p1 = reinterpret_cast<float*>(str);
//将char*转换为float*，危险

int *p = reinterpret_cast<int*>(100);
//将 int 转换为 int*