C++11_关键字_explicit

explicit是C++11中特意添加的一个关键字。通常情况下用于构造函数前面，表示显式表示，禁止构造函数的隐式转换。

为什么要这么做呢？这么做有什么好处呢？

我们先来看看下面的例子，顺便提几个知识点。

conversion function vs non-explicit-one-argument ctor

#include <iostream>
using namespace std;

class Fraction
{
    public:
        Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {}
    
        Fraction operator + (const Fraction& f) {
            return Fraction(...); 
        }
    	
    	operator double() const {
            return (double) m_numerator/m_denominator; 
        }
    
    private:
        int m_numerator;        // 分子
        int m_denominator;      // 分母
};
int main(void)
{
    Fraction f(3, 5); 
    Fraction d = f + 4;  // [Error]ambiguous

    return 0;
}

• 这段代码是编译不通过的，它会报第24行是[Error]ambiguous

为什么会这样呢？这就提到两个知识点：conversion function and non-explicit-one-argument ctor oparator

1 conversion function(转换函数)

1. 转换函数必须是类的成员函数
2. 转换函数不能声明返回类型
3. 形参列表必须为空
4. 类型转换函数通常应该是const

operator 类型名称() const {
        // 实现转换      
}

#include <iostream>
using namespace std;

class Fraction
{
    public:
        Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {}
        operator double() const {
            return (double) m_numerator/m_denominator; 
        }
    private:
        int m_numerator;        // 分子
        int m_denominator;      // 分母
};
int main(void)
{
    Fraction f(3, 5); 
    double d = 3.2 + f;
    cout << d << endl;

    return 0;
}

2 non-explicit-one-argument ctor

#include <iostream>
using namespace std;

class Fraction
{
    public:
        Fraction(int num, int den = 1) : m_numerator(num), m_denominator(den) {}
        Fraction operator + (const Fraction& f) {
            return Fraction(...); 
        }
    private:
        int m_numerator;        // 分子
        int m_denominator;      // 分母
};
int main(void)
{
    Fraction f(3, 5); 
    Fraction d = f + 4;

    return 0;
}

我们可以看到这两段代码都是可以编译通过的。这样就引出了最初文中那段代码编译不过的原因：

Fraction d = f + 4;

• 其有两种解释，会导致编译器无法识别该如何完成。

好，现在我们引出第三个知识点。

3. explicit-one-argument ctor

现在来用一个例子说明：

单一实参数构造函数如果没有用explicit声明，则会成为隐式转换函数。

class Foo {
public:
    explicit Foo(const string& name): name(name)
    {
    }
private:
    string name;
};


void ProcessFoo(const Foo& foo){}

int main(void)
{
    std::string test = "test";
    ProcessFoo(test);  // 编译不通过
    return 0;
}

上面的代码编译不通过，因为ProcessFoo需要的参数是Foo类型，传入的string类型不匹配。

如果将Foo构造函数的explicit关键字移除，那么调用ProcessFoo传入的string就会触发隐式转换，生成一个临时的Foo对象。 往往这种隐式转换是让人迷惑的，并且容易隐藏Bug，得到了一个不期望的类型转换。所以对于单参数的构造函数是要求explicit声明。

4 explicit 使用注意事项

1. C++ 中，一个参数的构造函数（或除了第一个参数以外其余参数都有缺省值的多参构造函数）承担了两个角色：
   • 用于构建单参数的类对象
   • 隐含的类型装换操作符
2. explicit 关键字只对一个参数的类构造函数有效，如果类构造函数参数大于或等于2个时，不会产生隐式转换，此时explicit 关键字无效。
3. explicit 可以用于拷贝构造函数，但是将拷贝构造函数声明为 explicit 并不是良好的设计，一般将单参数的 constructor 声明为 explicit ,而 copy constructor 不要声明为 explicit 。
4. 当函数的声明和定义分开写时，explicit 只能写在声明中，不能写在定义中。