c++ explicit 与 隐式转换

一、关键字 explicit

explicit， 顾名思义，即明确的，作为c++中的关键字。名如其意。
在C++中，我们有时可以将构造函数用作自动类型转换函数。但这种自动特性并非总是合乎要求的，有时会导致意外的类型转换，因此，C++新增了关键字explicit，用于关闭这种自动特性。即被explicit关键字修饰的类构造函数，不能进行自动地隐式类型转换，只能显式地进行类型转换。

注意：只有一个参数的构造函数，或者构造函数有n个参数，但有n-1个参数提供了默认值，这样的情况才能进行类型转换。

下面通过一段代码演示具体应用（无explicit情形）：

/* 示例代码1 */

class Demo
{
   public:
    Demo();    　　　　　　　　　　　　　　   /* 构造函数1 */
    Demo(double a);　　　　　　　　　　　　  /* 示例代码2 */
    Demo(int a,double b);　　　　　　　　   /* 示例代码3 */
    Demo(int a,int b=10,double c=1.6);　　/* 示例代码4 */
    ~Demo();
    void Func(void);

    private:
    int value1;
    int value2;
};

上述四种构造函数：

1. 构造函数1没有参数，无法进行类型转换！
2. 构造函数2有一个参数，可以进行类型转换，如：Demo test; test =12.2;这样的调用就相当于把12.2隐式转换为Demo类型。
3. 构造函数3有两个参数，且无默认值，故无法使用类型转换！
4. 构造函数4有3个参数，其中两个参数有默认值，故可以进行隐式转换，如：Demo test;test = 10;

下面讲述使用了关键字explicit的情况：

1 /* 示例代码2 */
 2 class Demo
 3 {
 4    public:
 5     Demo();    　　　　　　　　　　　　　　   /* 构造函数1 */
 6     explicit Demo(double a);　　　　　　　 /* 示例代码2 */
 7     Demo(int a,double b);　　　　　　　　   /* 示例代码3 */
 8
 9     ~Demo();
10     void Func(void);
11
12     private:
13     int value1;
14     int value2;
15 };

在上述构造函数2中，由于使用了explicit关键字，则无法进行隐式转换。即：Demo test;test = 12.2;是无效的！但是我们可以进行显示类型转换，如：

Demo test;
test = Demo(12.2); 或者
test = (Demo)12.2;

二、隐式转换

什么是c++隐式类型转换？

隐式转换指c++自动将一种类型转换成另一种类型，是编译器的一种自主行为。

为什么c++需要隐式类型转换？

• c++多态的特性，就是通过父类的对象实现对子类的封装，以父类的类型返回之类对象。
• c++中使用父类的地方一定可以使用子类代替，这也得益于隐式类型转换。
• c++是一种强类型的语言，有着非常严格的类型检查，采用隐式类型转换会使程序员更方便快捷一点。 但是在享受方便的时候，风险也紧跟其后。

隐式类型转换例子

int i=3; 
double j = 3.1;
i+j;//i会被转换成double类型，然后才做加法运算。

class A{};
class B: public A
{};//B是子类
void Fun(A& a);
B b;
Fun(b);//使用子类对象代替父类对象是可以的，也是因为隐式类型转换。

有时候隐式类型转换并不好

class Test
{
public:
Test(int i);
};

Test t1 = 1;//正确，由于强制类型转换，1先被Test构造函数构造成Test对象，
//然后才被赋值给t1
Test t2(1);//正确

这种情况有时候很好，如果程序员的本意就是如此，那可以省去好几行代码。
有时这种情况看起来就不那么好，可能是一个错误，程序员错误的写出了这行代码，但是它却奇迹般的没有导致错误，要是因此产生一个bug，那么将是灾难性的。
为了更准确的表达程序员的自我意愿，本着不怕多写几行代码的心，就使用c++ explicit关键词.

再比如有函数用到Test类

void fun(Test& t);
fun(1);//这样调用是没有问题的，隐式类型转换会把1转换成Test的对象。

总结

• 隐式类型转换，是编译器自发的行为，所以安全是第一位。所以呢，我们可以得出一条很重要的结论：
• 隐式类型转换是从小到大的转换。在数据类型上表现是少字节数据类型，转换成多字节数据类型，保证数据的完整性；在类上表现，从子类转换成父类，保证类对象功能的正常。
• 隐式类型转换往往是安全的，但是它可能产生意想不到的危险。

既然有隐式类型转换，那么肯定就有强制类型转换。既然是强制的，那么我们可以猜测一下几点：

• 强制类型转换，往往是不安全的，这点要使用者去把握，去了解这种使用是不是安全。
• 强制类型转换又是强大的，只要你能保证做的转换的正确性，那么它就是好用的。
• 强制类型转换和隐式类型转换，我们不能片面的看待他们是不是安全的。存在即合理，安不安全还是要看程序员自己在使用上是否正确，是否合理。