C++ explicit关键字的用法

// Type类的构造
class Type
{
private:
	int size;
public:
	Type () { }
	
	Type (int a)
	{
		size = a;
	}
	
	Type(const Type & T)
	{
		size = T.size;
	}
};

// 累的初始化
Type T1(10);       // 可行，T.size=10
Type T2 = 10;      // 可行，编译器使用隐式类型转换
Type T3(T1);       // 可行
Type T4 = T1;      // 可行

而在单参数构造函数和拷贝构造函数前面加上explicit关键字会阻止这种隐式转换，当使用赋值语法对类对象初始化时，编译错误。一般对单参数的构造函数都声明为explicit以阻止隐式的类型转换，以免造成未知错误。
　　例如下面使用explicit

// Type类的构造
class Type
{
private:
	int size;
public:
	Type () { }
	
	explicit Type (int a)
	{
		size = a;
	}

	explicit Type(const Type & T)
	{
		size = T.size;
	}
};

// 累的初始化
Type T1(10);       // 可行，T.size=10
Type T2 = 10;      // 不行，阻止隐式转换
Type T3(T1);       // 可行
Type T4 = T1;      // 不行

如果需要使用赋值语法初始化类对象，可以定义赋值运算符重载函数，例如下面的代码

class Type
{
private:
	int size;
public:
	Type () { }
	
	explicit Type (int a)
	{
		size = a;
	}
	
	explicit Type(const Type & T)
	{
		size = T.size;
	}

    int this_size()
    {
        return size;
    }

    void operator=(int a)
    {
        size = a;
    }

    Type & operator=(const Type& T)
    {
        size = T.size;
        return *this;     // 返回this指针的引用，可以连续赋值
    }
};

// 类的初始化
Type T1(10);      // 可行
Type T2;　　　　　　// 可行，默认构造函数
T2 = 10;          // 可行，调用赋值运算符重载函数
Type T3(T1);      // 可行，拷贝构造函数
Type T4;          // 可行，默认构造函数
T4 = T1;          // 可行，调用赋值运算符重载函数