explicit 关键字

1. explicit介绍

类的构造函数被声明为explicit方式，可以用来阻止隐式类型转换，但被声明为explicit的构造函数依然可被用来执行显示类型转换。即，explicit构造函数必须显示调用。

2. 隐式转换的弊端，以及例子

1. 关于隐式类型转换的规则：
   接受单个实参的构造函数，定义了从形参类型到该类类型的一个隐式转换。
   一个隐式转换的例子：

class A
{
public:
    A(int x) {
        cout<<"be invoked"<<endl;
    }
};
void func(A a) {
}

int main() {
    func(1); // 符合隐式转换规则，自动执行隐式转换，符合拷贝构造函数的调用时机（用实参初始化形参）；最终被转换为func(A(1))的形式。
    A a = 1; // 执行了隐式转换，等价于A a(1)；'=' 调用了默认拷贝构造函数。
return 0;
}

2. 实现隐式类型转换的方式：
   编译器提供的 默认拷贝构造函数（对于类，编译器会默认生成一个，只有一个参数且参数是类对象引用的构造函数）
   如：

class B
   {
   public:
       B(const B& obj) {  // 默认拷贝构造函数
        // 浅拷贝
        }
}

默认拷贝构造函数的作用：将源对象的非静态数据成员简单的拷贝到目标对象上。
默认拷贝构造函数的调用时机：
(1) 一个对象作为函数参数，以值传递的方式传入函数体。
(2) 一个对象作为函数返回值，以值传递的方式从函数返回。
(3) 一个对象用于给另外一个对象进行初始化。

(1)
class D {};
D a;    
D b(a);     // 调用拷贝构造函数
D c = a;    // 同上,调用拷贝构造函数 (初始化c)

(2)
class Test {};
void TestFunc_1(Test obj) {}    // 对象作为函数参数
void TestFunc_2(Test& obj) {}   // 对象的引用作为函数参数
int main() {
    Test a;
    Test &b = a;
    TestFunc_1(a);  // 对象直接作为参数，会调用拷贝构造函数
    TestFunc_2(b);  // 对象的引用作为参数，不会调用拷贝构造函数, 只传递该对象的地址.
    return 0;
}

Note: 对象作为函数参数时调用拷贝构造函数、引用做函数参数时只是传递地址。
（当用引用变量做参数时，不调用拷贝构造函数；用传递引用的方式给函数传递一个对象的引用时，只传递了该对象的地址，系统消耗较小。在函数体内访问形参，实际是访问了这个作为实参的对象）

3. 隐式转换的弊端：（例子）
   假设将整数或单个字符，转换为字符串。
   如：

#include <iostream>
#include<algorithm>
using std::cout;
using std::endl;
class ToStrA
{
public:
    ToStrA(int x) {
        cout << "ToStrA:: int to string" << endl;
    }
    ToStrA(const char* a) {
        cout << "ToStrA:: char to string" << endl;
    }
};
int main( ) {
    ToStrA atostr = 'a'; 
    // 期望输出：ToStrA:: a
    // 实际输出：ToStrA:: 97
    return 0;
}

原因：程序执行了隐式转换，'a'的ASCII码（int值）被传入，打印出数字字符串。而我们期待的是把'a'变成字符串。

4. 使用explicit声明构造函数之后：

#include <iostream>
#include<algorithm>
using std::cout;
using std::endl;
class ToStrB
{
public:
    explicit ToStrB(int x) {
        cout << "ToStrB:: int to string" << endl;
    }
    explicit ToStrB(const char* a) {
        cout << "ToStrB:: char to string" << endl;
    }
};
int main( ){
    ToStrB atostr_1 = 'a';
    return 0;
}

结果，编译时会直接报错，类型不能转换。如下：

explicit.cpp:60:20: error: conversion from ‘char’ to non-scalar type ‘ToStrB’ requested
   60 |  ToStrB atostr_1 = 'a';
      |                    ^~~

3. 总结

1. 建议：除非有一个很好的理由，去允许构造函数被用于隐式类型转换，否则把它声明为explicit。
2. 可接收单个参数的构造函数必需要加上explicit标记，禁止隐式类类型转换
   (拷贝和移动构造函数除外，因为这两者不执行类型转换）

拓展：

1. Google C++ Style Guide

2. 关于std::string的构造函数，并没有使用explicit关键字；
   

   std::string.png