[cpp deep dive] 构造函数与explicit

explicit

• explicit关键字只能修饰构造函数，其余地方不起作用.
• 单参数构造函数会起一个作用，即会令该参数类型的对象在某些时候（如函数参数）隐式转换为本类类型。而加了explicit之后则会禁止这种转换。
• 另外该关键字只要放在声明之前即可起作用，而非像inline一样，要放在函数体定义处才起作用.
• 他的作用是，令构造函数的隐式调用失效.只能显式地调用.比如复制构造函数假如加了之后，会令等号初始化和参数值传递都失效.
• 至于什么是隐式调用呢？这里先下个结论，后面详细讨论.
  • 同类型的复制涉及初始化隐式调用复制构造：obj_type obj2; obj_type obj1 = obj2;(隐式复制构造)与此相对应的是显式调用复制构造：obj_type obj2; obj_type obj1(obj2);(显式复制构造)
  • 不同类型的复制初始化涉及类型转换构造和复制构造（两者的调用都是隐式）obj_type obj = 1;先调用obj_type(int)生成一个临时对象，再通过复制构造给obj.
  • 参数传递/返回值,可能涉及类型转换构造和复制构造（隐式），与复制初始化类似.

我个人感觉这样的机制挺令人恶心的。

#include 
#define ____(str) printf("[DBG]:%s\n",str)

class base{
/*  
    private:
        base(const base& x) : val(x.val){//------------
            
        } 
*/
    public:
        base():val(0){
            ____("base()");
        }
        explicit base(int x) : val(x){//<---------------
            ____("base(int x)");
        }
/*  <--------------------------------------
        base(char c):val(c - 'a'){
            ____("base(char c)");
        }
*/
        int val;
};

void foo(base x)
{
    
}

int main(){
    
    base c(10);//<--------------<0> OK
    base c1('c'); //<-----------<1> OK convert 'c' to int and call `base(int x)`
    //foo('c');//<--------------<2> Not OK by explicit. error: could not convert ‘'c'’ from ‘char’ to ‘base’
    //foo(10);//<---------------<2.2>Not OK by explicit. error: could not convert ‘10’ from ‘int’ to ‘base’
    base c1_1(10.23); //<-------<3> OK
    //base c2 = 100; //<--------<4> Copy initialize
    foo(base(10));//<-----------<5> OK call `base(int x)` explicitly. WILL AFFECTED by  [COPY initial]
    return 0;
}

如果去掉处的注释，那么:
可以得到一个非explicit得构造函数，进而<2>和<2.2>将重新获得编译通过，并且foo将调用Z处的构造函数.同时，<3>由于二义性而失败.

构造函数的种类以及他们什么时候被调用

• 默认构造函数 (没有任何参数的构造函数称为默认构造函数)
• 类型转换构造函数（只有一个参数，且参数类型与该类的类型不一样）
  • 显式类型转换构造
  • 隐式类型转换构造
• 复制构造函数（形如 class_type(const class_type &)的）
  • 复制构造函数会被调用的情形包括：
    1)． 一个对象以值传递的方式传入函数体
    2)． 一个对象以值传递的方式从函数返回
    3)． 一个对象需要通过另外一个对象进行初始化，这里包括2种情形:
    • 显式复制构造
    • 隐式复制构造
    • 例如：

obj_class_type obj1;
obj_class_type obj2;
obj_class_type obj3 = obj1;//此为隐式复制构造，假如该类的复制构造函数声明中带`explicit`关键字，这里会编译错误.
/*
 *另，为了做对比，这里假如有 obj_class_type obj3 = 100; 100是int型，这里涉及了：
1. 一个隐式类型转换构造int ----> obj_class_type；
2.一个隐式复制构造调用
两个构造函数必须都没有explicit关键字才行！
当类型转换构造函数以explicit修饰时，编译错误为：error: conversion from ‘int’ to non-scalar type ‘base’ requested
当复制构造函数以explicit修饰时，编译错误为：error: no matching function for call to ‘base::base(base)’ 这里base是我定义的类.
但奇怪的是，假如在两个构造函数里分别打印信息或是修改某全局变量，却显示只有类型转换构造函数被调用。查了点资料，有可能是所谓的你看不见但存在的临时对象的锅！
  */
obj_class_type obj4(obj2);//此为显式复制构造

另外，初始化中的等号调用的不是赋值运算符而是复制构造函数！！！

为啥这里没有operator=呢？因为这玩意儿根本就不是构造函数！

附：关于隐式调用中复制构造函数参数的const问题.

---

• [Update9.6] - 由于隐式调用里是从临时变量中复制构造过来的，因此需要复制构造函数中参数必须为const.

附：一段丑陋且让人摸不着头脑的代码

---

-------------8.1更新，这就是传说中的复制初始化问题Copy Initialization--------------
可以查看这个thread和这个thread.
大家千万不要被代码运行结果和网上众多复制来复制去的中文资料所迷惑,直接stackoverflow或上c++ref去查.
主要观点就是：
base b = 100;
base b(100);
这两句，从结果上来看，都是调用参数为int类型的类型转换构造函数（conversion constructor），但对于第一句编译器内部是会产生一个临时对象（调用类型转换构造函数）然后 通过复制构造函数来把这个临时对象复制给对象b，那你会问，为啥结果没有显示呢？下面这个截图可以告诉你：我们的复制构造函数被编译器优化了！他的做法是把复制构造函数放进private进行验证，而我们这是用explicit进行验证.

来自[thread](http://blog.csdn.net/ljianhui/article/details/9245661)的截图

#include 
#include 
#define ____(name,str) printf("[OBJ:%s] %s\n", name.c_str(),str)

static std::string OBJ_NAME = "ABCD";

class base{
    public:
        base() : val(){ n = OBJ_NAME; OBJ_NAME = OBJ_NAME + "#"; }
        
        base(int x) : val(x){ //类型转换构造函数
            n = OBJ_NAME; 
            OBJ_NAME = OBJ_NAME + "#";
            ____(n,"base(int x) is called!");
        }
        
        base(const base& x);//explicit base(const base& x); ******<1> Complile_Error:error: no matching function for call to ‘base::base(base)’
        
        base& operator=(const base& x){
            if(this == &x){
                //
            }   
            ____(n,"operator= is called!");
            return *this;
        }
        
        
        ~base(){
            ____(n,"destructor is called!");
        }
        
        void name(){
            ____(n,"");
        }
        
        int val;
        std::string n;
};
base::base(const base& x) : val(x.val){ 
    n = OBJ_NAME; 
    OBJ_NAME = OBJ_NAME + "#";
    ____(n,"copy construct is called!");
}
void foo2(const base& x)//void foo2(base& x)*******<2>
{
    
}

void foo(base x)
{
    
}
int main(){
    base b = 100;//********
    foo(200);//*********
    foo2(201);
    
    return 0;
}

上面这段代码运行结果如下

work@vm1:~/share/toys/CSE274.me/02_Cpp_Intro$ ./test
[OBJ:ABCD] base(int x) is called!
[OBJ:ABCD#] base(int x) is called!
[OBJ:ABCD#] destructor is called!
[OBJ:ABCD##] base(int x) is called!
[OBJ:ABCD##] destructor is called!
[OBJ:ABCD] destructor is called!

所在的这行代码发生了什么？
我推测应该是：

1. 100这个int生成了一个临时对象（调用了类型转换构造函数）
2. b对象的复制构造构造函数通过传入这个临时对象（该函数的参数必须是const类型，否则编译出错）
   但是，结果却显示没有任何复制构造函数被调用.
   好，那既然没有任何复制构造函数被调用，那我就把<1>所在行声明为explicit，因为我只对复制构造函数做的改变，按理说应该没有影响才对，但奇特的是却编译错误.no matching function for call to ‘base::base(base)’

另外还有一个问题就是所在行代码发生了什么？
我推测应该也是：

1. 200这个int生成了一个临时对象（调用了类型转换构造函数）
2. 值传递，该临时对象通过复制构造函数，复制给了参数x.
   然而，也没有任何证据显示复制构造函数被调用，好嘛，那我同样把复制构造函数设为explicit，你们这些隐式的调用都给老子去屎，果然，编译错误，foo(200)这行no matching function for call to ‘base::base(base)’.

所以，结论：虽然复制构造函数在运行的时候没有体现被调用，但依然会幽灵一样对实验程序的运行带来影响.所以这里就有人建议不要用带等号的初始化。

<2>所在处的参数必须为const，否则编译错误.原因是c++对于临时对象只能以const引用，否则让你修改了临时对象，那还得了？！同理，复制构造函数的参数也只能是const，否则，你执行带等号的初始化（也就是复制初始化）时，一样会出现这个错误！

• [Update9.6] - 上面这段加上编译参数-fno-elide-constructors后，结果如下：(露出了真面目)

work@vm1:initialize$ g++ piece.cc -o test -fno-elide-constructors
work@vm1:initialize$ ./test
[OBJ:ABCD] base(int x) is called!
[OBJ:ABCD#] copy construct is called!
[OBJ:ABCD] destructor is called!
[OBJ:ABCD##] base(int x) is called!
[OBJ:ABCD###] copy construct is called!
[OBJ:ABCD###] destructor is called!
[OBJ:ABCD##] destructor is called!
[OBJ:ABCD####] base(int x) is called!
[OBJ:ABCD####] destructor is called!
[OBJ:ABCD#] destructor is called!

附： 关于编译器自动生成的构造函数.

---

1. 假如用户定义类型没有任何构造函数，编译器会自动生成的函数：（只要有需要的话）

• 默认构造函数 (没有任何参数的构造函数称为默认构造函数)
• 复制构造函数
• 析构函数 ----之后讨论析构
• 赋值运算符

2. 假如用户定义了某个构造函数，编译器就不会自动生成默认构造函数(*)，但如果有需要，还是会自动生成其他3个函数.
   若用户没有定义默认构造函数，那么C风格的声明该类会报错.
   base2 b2_1;base2 b2_1_1 = base2();例如这些，其中base2类你定义了一个构造函数，但没默认构造函数.----error: no matching function for call to ‘base2::base2()’

3. 编译器自动生成的：(都是public)

• 默认构造函数，就是一个空函数，即什么也不做，不初始化也不在函数体内赋值，因此只要该实例为局部变量且使用了编译器自动生成的默认构造函数，则内部成员是随机值.
• 复制构造函数， 按值复制，即将参数（const type& ）中的各个成员赋值给本对象的各个成员。<--------一般情况下不会有啥问题，但如果你的成员中带有一个指针成员，ok，完了，当复制的成员析构时，可能会把原始成员的这个指针给free了。（即浅拷贝存在的问题）
• 赋值运算符