【C++】隐式类型转换的风险举例及使用explict的必要性

隐式转换的风险

隐式转换的风险一般存在于自定义的类构造函数中。 按照默认规定，只有一个参数的构造函数也定义了一个隐式转换，将该构造函数对应数据类型的数据转换为该类对象。

如：

class String
{
public:
    String (const char* p);       // 用 C 风格的字符串p作为初始化值
}
...
String s1 = "hello";              // OK 隐式转换，等价于 String s1 = String("hello")

但是有时可能会不需要这种隐式转换，如：

class String
{
public:
    String( int n);               // 本意是预先分配 n 个字节给字符串
    String( const char* p);       // 用 C 风格的字符串 p 作为初始化值
}
...
String s2(10);                    // OK 分配10个字节的空字符串
String s3 = String(10);           // OK 分配10个字节的空字符串

String s4 = 10;                  // 编译通过，也是分配10个字节的空字符串
String s5 = 'a';                 // 编译通过，分配 int('a') 个字节的空字符串
// s4 和 s5 分别把一个 int 型和 char 型，隐式转换成了分配若干字节的空字符串，容易令人误解。

再如：

class Test
{
public:
    Test(int a);
    bool isSame(Test other)
    {
        return m_val == other.m_val;
    }
private:
    int m_val;    
}

Test a(10);
if(a.isSame(10));                   // 该语句将返回true

本来用于两个Test对象的比较，对象 a 竟然和 int 类型相等了。这就是由于发生了隐式转换，实际上进行比较的是一个临时的 Test 对象。发生了异常。

禁止隐式转换：explicit

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

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

class Test
{
    explicit Test(int a);
}

Test aa(10);                         // OK 
Test aa = 10;                        // 非法，此操作被禁止。加入explicit 可以有效的防止隐式转换的发生，提高程序质量。
Test bb = aa;                        // 非法，取消了隐式转换，除非重载操作符“=”