C++ explicit关键字详解

单参数构造函数

---

单参数构造函数作为隐含的类型转换符号

---

C++中，一个参数的构造函数(或者除了第一个参数外其余参数都有缺省值的多参构造函数)，承担了两个角色。

• 用于构建单参数的类对象
• 隐含的类型转换操作符．

例如一个类A的构造函数A(int i)就是，既可以用来作为构造器，又可以实现隐式转换A a=1；因为1可以通过构造函数A(int i)转换为一个类A的对象。

#include 

class Base
{
public :
    Base(const char data)
    {
        std::cout <<"constructor..." <<std::endl;
        this->m_data = data;
    }

protected :

    char m_data;
};



int main(void)
{
    Base base1('a');        // 用于构建单参数的类对象
    Base base2 = 'b';     // 隐含的类型转换操作符

    return 0;
}

这种方法看起来很方便，但是有时这并不是我们想要的，但是由此可能引入一些其他问题。

由此带来的问题

---

比如如下的代码就可以正常运行

Base base = 10000;  //   由于10000可以被转成char类型

因此C++提供关键字explicit，可以阻止不应该允许的经过转换构造函数进行的隐式转换发生．
特别对于如下代码

#include 


#include 


class Base
{
public :
    Base(const char *str)
    {
        std::cout <<"constructor..." <<std::endl;

        this->m_length = strlen(str);
        this->m_cstr = new char[this->m_length + 1];

        strcpy(this->m_cstr, str);
    }

    Base(const Base &base)
    {
        this->m_length = base.m_length;
        this->m_cstr = new char[this->m_length + 1];

        strcpy(this->m_cstr, base.m_cstr);
    }

    ~Base()
    {
        delete this->m_cstr;
    }

protected :

    char *m_cstr;
    int  m_length;
};



int main(void)
{
    Base base = (char *)10000;     // 隐含的类型转换操作符

    return 0;
}

声明为explicit的构造函数不能在隐式转换中使用，只能显示调用，去构造一个类对象。

拷贝构造函数copy construct

---

Copy constructor也是同样的，如果Copy constructor被声明为explicit，则这个类对象不能用于传参和函数返回值。但是仍然可以直接调用。

拷贝构造函数的调用时机

---

我们都知道，在C++中，拷贝构造函数的调用时机有如下三种情况

1. 当用类的一个对象去初始化该类的另一个对象时
2. 如果函数的形参是类的对象，调用函数，进行形参和实参结合时
3. 如果函数的返回值是类的对象，函数执行完成返回调用者时

#include 

class Base
{
public :
    Base( )
    {
        //std::cout <<"default constructor..." <
        this->m_data = '\0';
    }

    Base(char data)
    {
        //std::cout <<"simple constructor..." <
        this->m_data = data;
    }

    Base(const Base &base)
    {
        std::cout <<"copy constructor..." <<std::endl;
        this->m_data = base.m_data;
    }

protected :

    char m_data;
};


//  参数为Base对象
void Func(const Base base)
{
}

//  返回值为base对象
Base Func( )
{
    Base base;

    return base;
}

void Copy()
{
    Base b1;
    Base b2 = b1;

}

int main(void)
{
    Base base(10);

    std::cout  <<std::endl <<"参数为Base对象..." <<std::endl;
    Func(base);     //  优化未优化情况下均调用1次拷贝构造函数

    std::cout  <<std::endl <<"返回值为base对象[可被优化]..." <<std::endl;
    Func();     //  优化情况下调用0次, 未优化情况下调用1次[函数返回时调用]

    Base b = Func();     //  优化情况下调用0次, 未优化情况下调用2次[函数返回时调用 + 初始化类型b时调用]


    std::cout  <<std::endl <<"用base对象初始化另外一个对象..." <<std::endl;
    Copy();     //  优化未优化情况下均调用1次拷贝构造函数

    return 0;
}

但是其实很多现代编译器的返回值优化技巧，返回值时的情况会被优化掉，但是这个并不是我们今天讨论的重点。

具体可参见

RVO-编译器返回值优化

在使用GNU/g++编译器时可以使用”-fno-elide-constructors”选项来强制g++总是调用copy构造函数，即使在用临时对象初始化另一个同类型对象的时候（主要是返回值为）

explicit对拷贝构造函数也会限制作用，将会阻止隐式拷贝构造函数的调用。
explicit对拷贝构造函数也会限制作用，将会阻隐式拷贝构造函数的调用．

将拷贝构造函数声明为explicit，则会阻止隐式拷贝构造函数的调用。

explicit关键字对拷贝构造函数的限制

---

这时候我们可以将参数传递或者函数返回修改为引用的方法，而初始化的时候采用显式调用拷贝构造函数。

#include 

class Base
{
public :
    Base( )
    {
        //std::cout <<"default constructor..." <
        this->m_data = '\0';
    }

    explicit Base(char data)
    {
        //std::cout <<"simple constructor..." <
        this->m_data = data;
    }

    explicit Base(const Base &base)
    {
        std::cout <<"copy constructor..." <<std::endl;
        this->m_data = base.m_data;
    }

protected :

    char m_data;
};


//  参数为Base对象
void Func(const Base& base)     //  传入引用对象
{
}

//  返回值为base对象
Base& Func( )
{
    Base base;

    return base;            //  返回引用对象
}

void Copy()
{
    Base b1;
    Base b2(b1);            //  Base b2 = b1显示调用拷贝构造函数

}

int main(void)
{
    Base base(10);

    std::cout  <<std::endl <<"参数为Base对象..." <<std::endl;
    Func(base);     //  优化未优化情况下均调用1次拷贝构造函数

    std::cout  <<std::endl <<"返回值为base对象[可被优化]..." <<std::endl;
    Func();     //  优化情况下调用0次, 未优化情况下调用1次[函数返回时调用]

    //Base b(Func());     返回局部对象


    std::cout  <<std::endl <<"用base对象初始化另外一个对象..." <<std::endl;
    Copy();     //  优化未优化情况下均调用1次拷贝构造函数

    return 0;
}

总结

---

C++中，一个参数的构造函数(或者除了第一个参数外其余参数都有缺省值的多参构造函数)，承担了两个角色。

• 用于构建单参数的类对象
• 隐含的类型转换操作符

声明为explicit的构造函数不能在隐式转换中使用，只能显示调用，去构造一个类对象。

explicit关键字只对有一个参数的类构造函数有效, 如果类构造函数参数大于或等于两个时, 是不会产生隐式转换的, 所以explicit关键字也就无效了

但是将拷贝构造函数声明成explicit并不是良好的设计，一般只将有单个参数的constructor声明为explicit，而copy constructor不要声明为explicit.