explicit（显式）关键字

/**
 *  explicit（显式）关键字
 * -explicit 修饰构造函数时，可以防止隐式转换和复制初始化
 * -explicit 修饰转换函数时，可以防止隐式转换，但按语境转换除外
 * compile:g++ explicit.cpp -std=c++11
 * */

#include <iostream>

struct A
{
    A(int){}
    operator bool() const { return true; }
};

// explicit usage
struct B
{
    explicit B(int){}
    explicit operator bool() const { return true; }
};

void doA(A a){}

void doB(B b){}

int main(int argc,char* argv[])
{
    A a1(1);                            //OK:直接初始化
    A a2 = 1;                           //OK:复制初始化
    A a3{2};                            //OK:直接列表初始化
    A a4 = {2};                         //OK:复制列表初始化
    A a5 = (A)1;                        //OK:允许static_cast的显示转换
    doA(1);                             //OK:允许从int到A的隐式转换
    if(a1);                             //OK:使用转换函数A::operator bool()的从A到bool的隐式转换
    bool a6(a1);                        //OK:使用转换函数A::operator bool()的从A到bool的隐式转换
    bool a7 = a1;                       //OK:使用转换函数A::operator bool()的从A到bool的隐式转换
    bool a8 = static_cast<bool> (a1);   //OK:static_cast进行直接初始化

    /*--------------------------------------------------------------------------------------*/

    B b1(1);                            //OK:直接初始化
    // B b2 = 1;                           //ERROR:被 explicit 修饰构造函数的对象不可以复制初始化
    B b3{2};                            //OK:直接列表初始化
    // B b4 = {2};                         //ERROR:被 explicit 修饰构造函数的对象不可以复制列表初始化
    B b5 = (B)1;                        //OK:允许static_cast的显示转换
    // doB(1);                             //ERROR：被 explicit 修饰构造函数的对象不可以从 int 到 B 的隐式转换
    if(b1);                             //OK:使用转换函数A::operator bool()的从B到bool的隐式转换
    bool b6(b1);                        //OK:使用转换函数A::operator bool()的从B到bool的隐式转换
    // bool b7 = b1;                       //ERROR：被 explicit 修饰转换函数 B::operator bool() 的对象不可以隐式转换
    bool b8 = static_cast<bool> (b1);   //OK:static_cast进行直接初始化 

    return 0;
}