隐式转换：

基本类型的隐式转换：

当函数参数类型非精确匹配，但是可以转换的时候发生

如：

void func1(double x){cout << x << endl;
}void func2(char c){cout << c << endl;
}int main(){func1(2);//int隐式转换为doublefunc2(3);//int隐式转换为charreturn 0;
}

自定义类型的隐式转换：

函数参数列表接受类类型变量，传入的单个参数不是类对象，但可以通过这个参数调用类对应的构造函数，那么编译器就会将其隐式转换为类对象

如：

class A{
private:int a;
public:A(int x):a{x}{}
};
void func(A a){cout << "func" << endl;
}int main(){func(1);//隐式将int转换为A对象A obj = 1;//同上return 0;
}

多参数构造函数：

调用多参数构造函数时，将所有参数用用{}括起来，表示是一个初始化列表，但这并不属于自定义类型隐式转换，而是隐式构造

class A{
private:int a;
public:A(int x):a{x}{}
};class B{
private:A obj;int b;
public:B(A a,int x):obj{a},b{x}{}
};void func(B b){cout << "func" << endl;
}
int main(){func({A{1}, 2});//使用{A,int}隐式构造B对象func({1,2});//仍能运行，隐式将1转换为A对象，然后用{A,int}隐式构造B对象return 0;
}

值得注意：

自定义的类型转换不能连续发生两次以上，否则会报错

例如：

class A{
private:string str;
public:A(const string& s):str{s}{}
};void func(A a){cout << "func"<<endl;
}int main(){func("Hello");//报错，因为需要将const char*隐式转换为string,string转换为const string,//再将string隐式转换为A//需要发生两次自定义类型隐式转换func(string{"Hello"});//编译通过，只需要string转换为const string,再将string隐式转换为A,//只发生一次自定义类型隐式转换return 0;
}

禁止任何隐式调用的关键字：explicit

在类构造函数前加上explicit关键字，则该构造函数无法再被隐式转换或隐式构造

从而防止某些错误的函数调用，比如想传入int却被隐式转换为了类对象

class A{
public:explicit A(int x){cout << x << endl;}explicit A(int x,int y){cout << x << y << endl;}
};A func(int a,int b){return {a, b};//禁止{int,int}到A的隐式构造
}A func(int x){return A{x};//合法return A{x, x};//合法
}int main(){A a = 1;//禁止int到A的隐式转换return 0;
}

好习惯：

将所有接受单个参数（包括多个参数，但只有一个参数没有缺省值的）的构造函数都限定为explicit

拷贝构造和移动构造不应该限定为explicit

显式转换：

初始化列表式转换：

使用type{var}的方式进行转换，如int{'c'}

这种转换只允许小范围变量向大范围变量转换，不允许反向，如

int x{3.5};//不被允许截断
long long y{3};
cout<<double{y}<<endl;//不允许被截断

C风格转换：

使用类似(int),或者int()的方式来转换类型，底层是组合调用了C++的各种cast函数来进行转换，因此不推荐使用这种转换

在这种转换中，尝试的cast调用顺序：

const_cast

static_cast

static_cast+const_cast

reinterpret_cast

reinterpret_cast+const_cast

const_cast转换:

实际极少使用

使用方式:

const_cast<to_type>(var)

作用：

给变量添加/去除const属性

如果该变量本身就是const变量，则无法真正地去除const属性

例如：

int main(){const int x = 2;const int *p = &x;int *p2 = const_cast<int *>(p);*p2 = 3;cout << x << endl;cout << *p2 << endl;return 0;
}

输出：

2
3

这里我们试图去除p所指向的的变量的const属性，并通过p2来修改其值，但在打印x时输出的值仍为2，这是因为编译器在编译的时候知道x为const变量，因此将cout<<x直接优化成了cout<<2，从而保证了其不会被修改。

而我们尝试使用p2去修改x的值，这属于未定义行为，需避免。因此，对于本身为const属性的变量，我们不应该使用const_cast来去除其const属性，否则可能会导致未定义行为

const_cast用于去除本来不是const变量的const属性

如：

void func(const int*p){int *p2 = const_cast<int *>(p);//用来去除被函数传参过程中隐式添加的const属性*p2 = 6;
}int main(){int x = 3;const int *p = const_cast<const int *>(&x);//人为为其添加const属性，使其无法被修改//在经过了一段时间的应用后，现在又想修改x的值了int *p2 = const_cast<int *>(p);*p2 = 5;cout << *p << endl;func(&x);cout << *p << endl;return 0;
}

static_cast转换:

使用方式:

static_cast<to_type>(var)

作用：

1.进行基本类型之间的转换（允许截断，告诉编译器是有意为之的截断）

相比之下，列表初始化转化不允许截断，因此更推荐使用static_cast进行转换，当然程序员要负起截断的责任，告诉大家这是有意为之的截断，而不是自己大意导致的截断

int x=static_cast<int>(3.14);

2.进行安全性检查，不允许无关类型指针互转

int main(){double x = 3.2;int *p2 = static_cast<int *>(&x);//不合法return 0;
}

3.可以将void*指针转为任意类型指针

无安全性检查，需要保证指向的类型正确(下例为不正确用法)

int main(){double x = 3.2;int *p2 = static_cast<int *>(static_cast<void*>(&x));//通过double*转void*，再从void*转到int*，跳过了安全性检查return 0;
}

4.将派生类指针/引用/对象转换为基类指针/引用/对象（向上转换）

class Base{
};
class Derived:public Base{
};
int main(){Base *p_b = static_cast<Base *>(new Derived);Derived d;Base &ref_b = static_cast<Base &>(d);Base obj_b = static_cast<Base>(d);//导致对象切片
}

5.将基类指针/引用转换为派生类指针/引用（向下转换，不推荐）

无安全性检查，需要保证基类指针指向要转换的派生类或者其派生类

若基类派生类拥有虚函数，应优先使用dynamic_cast(下文讲解)

Base* p_b2=new Derived;
Derived* p_d=static_cast<Derived*>(p_b2);//合法

6.显式调用自定义构造函数/类型转换函数进行转换

class MyInt {
public:explicit MyInt(int x) : value(x) {}operator int() const { return value; }  // 自定义的转换运算符
private:int value;
};MyInt mi = static_cast<MyInt>(42);  // 调用构造函数
int x = static_cast<int>(mi);       // 调用 operator int()