explicit构造函数

原文：http://www.cnblogs.com/cutepig/archive/2009/01/14/1375917.html

按照默认规定，只有一个参数的构造函数也定义了一个隐式转换，将该构造函数对应数据类型的数据转换为该类对象，如下面所示：

class String {

String ( const char* p );  // 用C风格的字符串p作为初始化值

//…

}

String s1 = “hello”; //OK 隐式转换，等价于String s1 = String（“hello”）;

 

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

class String {

       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型，隐式转换成了分配若干字节的空字符串，容易令人误解。

为了避免这种错误的发生，我们可以声明显示的转换，使用 explicit 关键字：

class String {

        explicit String ( int n ); //本意是预先分配n个字节给字符串

String ( const char* p );  // 用C风格的字符串p作为初始化值

//…

}

加上 explicit，就抑制了String ( int n )的隐式转换，

 

下面两种写法仍然正确：

String s2 ( 10 );   //OK 分配10个字节的空字符串

String s3 = String ( 10 ); //OK 分配10个字节的空字符串

 

下面两种写法就不允许了：

String s4 = 10; //编译不通过，不允许隐式的转换

String s5 = ‘a’; //编译不通过，不允许隐式的转换

 

因此，某些时候， explicit 可以有效得防止构造函数的隐式转换带来的错误或者误解

----------------------------------------------------------
explicit   只对构造函数起作用，用来抑制隐式转换。如：   
  class   A   {   
          A(int   a);   
  };   
  int   Function(A   a);   
    
  当调用   Function(2)   的时候，2   会隐式转换为   A   类型。这种情况常常不是程序员想要的结果，所以，要避免之，就可以这样写：   
    
  class   A   {   
          explicit   A(int   a);   
  };   
  int   Function(A   a);   
    
  这样，当调用   Function(2)   的时候，编译器会给出错误信息（除非   Function   有个以   int   为参数的重载形式），这就避免了在程序员毫不知情的情况下出现错误。

总结：explicit   只对构造函数起作用，用来抑制隐式转换。

原文：http://blog.csdn.net/fornormandy/article/details/79512

Pointer

不看书不知道自己的C++有多差T_T，看到 explicit 时遇到一个问题。请看下面一段程序：
class A{
public:
A(int i) : m_i(i){}
int m_i;
};
int main(){
A a = 0;
a = 10; // 这里是什么操作？
}

这个操作产生了一个临时对象。
我怀疑是默认赋值运算符 “A &operator = (int i){}”，于是重载了一下该运算符，结果确实运行到重载的运算符函数里了，那么临时对象又是如何产生的呢？

难道默认的赋值运算符是这样操作的？
A &operator = (int i){
A a(i);
return a;
}

这让我想起了类似的函数操作：
void fn(A a){
// ...
}
这里可以直接写fn(10);也是产生了一个临时对象。

难道真的是这样吗？忘解惑。

---

alexeyomux

老兄你用的是哪个编译器？在我印象之中，好像标准C++并不会给出operator =啊。等我去试一试。

---

gongminmin

当然会有默认的operator=了
按照c++标准，编译器会生成五个默认成员函数:
默认构造函数
拷贝构造函数
析构函数
operator=
operator&

 

千里马肝

class A
{
public:
A(int i) : m_i(i){}
int m_i;
};

分别说说吧：
1. A a = 0;
首先, compiler认为这样写是不符合规矩的, 因为A = A才是正常行为。
但是她并不放弃, 通过搜索, 发现A可以根据一个int构造, 同时这个A(int i)没有用explicit修饰过。
那么A a = 0; 这样的一句话随即转变成：
A tmp(0);
A a = tmp;
需要说明的是, A a = tmp是调用的copy ctor, 虽然class A中并没有, 但是通常不写copy ctor的话,
compiler都会生成一个memberwise assignment操作性质的ctor, 底层实现通常会以memcpy进行。

2. a = 10;
首先, 这样同ctor的情况一样, compiler无法直接进行操作。
类推, 等同于代码:
A tmp(10);
a = tmp;
需要注意的是, a = tmp是调用的assignment操作, 同ctor一样，我们自己不写, 编译器同样进行
memberwise assignment操作。

3. fn(A a)
同样, fn(10)也是不对的, 但是"按照惯例", 呵呵, 会有:
A tmp(10);
fn(tmp); 

另外, 为你解惑:
copy ctor的写法只能是T::T(const T &);
而assignment的写法可以多变, 即任意. 以T为例, 
可以有
T &operator = (int n);
也可有
T &operator = (const char *);
当然, 你要确认如此的定义是对T而言有意义.

然后, 上述a = tmp, 即调用的默认的、标准的、自动生成的T &operator = (const T &). 
开销是会有一个临时的A tmp生成, 然后memcpy.
但如果你自已写了T &operator = (int n), 那么a = 10即意味着a.m_i = 10. 
当然, 以开销而言要视你的T &operator = (int n)是否为inline了.

对于explicit, 当修饰explicit A(int i) : m_i(i){}, 那么即告诉compiler不要在私底下做那么多的转换动作.
而且自动生成如A tmp(0)这样的东西是我们不想要的, 因为某些情况下自动转换这种行为是错误的.
（貌似临时开辟空间后再转换的功能被关闭了，会被编译器认为错误，这样关闭了=操作，只允许A=A操作）
最后, 相关此类问题, 还有一个话题, 即class A可以有operator int(), 会在
fn(int n){}
A a(3);
fn(a)
起到魔术般的作用. 关于这个, 留给你自己看看书吧:)