C++ 构造函数 explicit 关键字成员初始化列表

通常，构造函数具有public可访问性，但也可以将构造函数声明为 protected 或 private。构造函数可以选择采用成员初始化表达式列表，该列表会在构造函数主体运行之前初始化类成员。与在构造函数主体中赋值相比，初始化类成员是更高效的方式。首选成员初始化表达式列表，而不是在构造函数主体中赋值。

注意：

成员初始化表达式的参数可以是构造函数参数之一、函数调用或 std::initializer_list。
const 成员和引用类型的成员必须在成员初始化表达式列表中进行初始化。
若要确保在派生构造函数运行之前完全初始化基类，需要在初始化表达式中初始化化基类构造函数。

class Box {

public:

    // Default constructor

    Box() {}

    // Initialize a Box with equal dimensions (i.e. a cube)

    explicit Box(int i) : m_width(i), m_length(i), m_height(i) // member init list

    {}

    // Initialize a Box with custom dimensions

    Box(int width, int length, int height)

        : m_width(width), m_length(length), m_height(height)

    {}

    int Volume() { return m_width * m_length * m_height; }

private:

    // Will have value of 0 when default constructor is called.

    // If we didn't zero-init here, default constructor would

    // leave them uninitialized with garbage values.

    int m_width{ 0 };

    int m_length{ 0 };

    int m_height{ 0 };

};

派生构造函数运行之前完全初始化基类

class Box {

public:

    Box(int width, int length, int height){

       m_width = width;

       m_length = length;

       m_height = height;

    }

private:

    int m_width;

    int m_length;

    int m_height;

};

class StorageBox : public Box {

public:

    StorageBox(int width, int length, int height, const string label&) : Box(width, length, height){

        m_label = label;

    }

private:

    string m_label;

};

构造函数可以声明为 inline、explicit、friend 或 constexpr。可以显式设置默认复制构造函数、移动构造函数、复制赋值运算符、移动赋值运算符和析构函数。

class Box2

{

public:

    Box2() = delete;

    Box2(const Box2& other) = default;

    Box2& operator=(const Box2& other) = default;

    Box2(Box2&& other) = default;

    Box2& operator=(Box2&& other) = default;

    //...

};

一、默认构造函数

如果类中未声明构造函数，则编译器提供隐式 inline 默认构造函数。编译器提供的默认构造函数没有参数。如果使用隐式默认构造函数，须要在类定义中初始化成员。

class Box {

public:

    int Volume() {return m_width * m_height * m_length;}

private:

    // 如果没有这些初始化表达式，成员会处于未初始化状态，Volume() 调用会生成垃圾值。

    int m_width { 0 };

    int m_height { 0 };

    int m_length { 0 };

};

如果声明了任何非默认构造函数，编译器不会提供默认构造函数。如果不使用编译器生成的构造函数，可以通过将隐式默认构造函数定义为已删除来阻止编译器生成它。

class Box {

public:

    // 只有没声明构造函数时此语句有效

    Box() = delete;

    Box(int width, int length, int height)

        : m_width(width), m_length(length), m_height(height){}

private:

    int m_width;

    int m_length;

    int m_height;

};

int main(){

    Box box1(1, 2, 3);

    Box box2{ 2, 3, 4 };

    Box box3; // 编译错误 C2512: no appropriate default constructor available

    Box boxes[3]; // 编译错误 C2512: no appropriate default constructor available

    Box boxes[3]{ { 1, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; // 正确

}

二、显式构造函数

如果类的构造函数只有一个参数，或是除了一个参数之外的所有参数都具有默认值，则会发生隐式类型转换。

class Box {

public:

    Box(int size): m_width(size), m_length(size), m_height(size){}

private:

    int m_width;

    int m_length;

    int m_height;

};

class ShippingOrder

{

public:

    ShippingOrder(Box b, double postage) : m_box(b), m_postage(postage){}

private:

    Box m_box;

    double m_postage;

}

int main(){

    Box b = 42; // 隐式类型转换

    ShippingOrder so(42, 10.8); // 隐式类型转换

}

explicit关键字可以防止隐式类型转换的发生。explicit只能用于修饰只有一个参数的类构造函数,表明该构造函数是显示的而非隐式的。

explicit关键字的作用就是防止类构造函数的隐式自动转换。
如果类构造函数参数大于或等于两个时, 不会产生隐式转换的, explicit关键字无效。
例外, 就是当除了第一个参数以外的其他参数都有默认值的时候, explicit关键字依然有效。
explicit只能写在在声明中，不能写在定义中。

三、复制构造函数

从 C++11 中开始，支持两类赋值：复制赋值和移动赋值。赋值操作和初始化操作都会导致对象被复制。

赋值：将一个对象的值分配给另一个对象时，第一个对象将复制到第二个对象。

初始化：在声明新对象、按值传递函数参数或从函数返回值时，将发生初始化。

编译器默认会生成复制构造函数。如果类成员都是简单类型（如标量值），则编译器生成的复制构造函数已够用。如果类需要更复杂的初始化，则需要实现自定义复制构造函数。例如，如果类成员是指针，编译器生成的复制构造函数只是复制指针，以便新指针仍指向原内存位置。

复制构造函数声明方式如下：

    Box(Box& other); // 尽量避免这种方式，这种方式允许修改other

    Box(const Box& other); // 尽量使用这种方式，它可防止复制构造函数意外更改复制的对象。

    Box(volatile Box& other);

    Box(volatile const Box& other);

    // 后续参数必须要有默认值

    Box(Box& other, int i = 42, string label = "Box");

    Box& operator=(const Box& x);

定义复制构造函数时，还应定义复制赋值运算符 (=)。如果不声明复制赋值运算符，编译器将自动生成复制赋值运算符。如果只声明复制构造函数，编译器自动生成复制赋值运算符；如果只声明复制赋值运算符，编译器自动生成复制构造函数。如果未定义显式或隐式移动构造函数，则原本使用移动构造函数的操作会改用复制构造函数。如果类声明了移动构造函数或移动赋值运算符，则隐式声明的复制构造函数会定义为已删除。

阻止复制对象时，需要将复制构造函数声明为delete。如果要禁止对象复制，应该这样做。

  Box (const Box& other) = delete;

三、移动构造函数

当对象由相同类型的另一个对象初始化时，如果另一对象即将被毁且不再需要其资源，则编译器会选择移动构造函数。移动构造函数在传递大型对象时可以显著提高程序的效率。

#include "MemoryBlock.h"

#include <vector>

using namespace std;

int main()

{

   // vector 类使用移动语义，通过移动矢量元素（而非复制它们）来高效地执行插入操作。

   vector<MemoryBlock> v;

  // 如果 MemoryBlock 没有定义移动构造函数，会按照以下顺序执行

  // 1. 创建对象 MemoryBlock(25)

  // 2. 复制 MemoryBlock 给push_back

  // 3. 删除 MemoryBlock 对象

   v.push_back(MemoryBlock(25));

  // 如果 MemoryBlock 有移动构造函数，按照以下顺序执行

  // 1. 创建对象 MemoryBlock(25)

  // 2. 执行push_back时会调用移动构造函数，直接使用MemoryBlock对象而不是复制

   v.push_back(MemoryBlock(75));

}

创建移动构造函数

定义一个空的构造函数，构造函数的参数类型为右值引用；
在移动构造函数中，将源对象中的类数据成员添加到要构造的对象；
将源对象的数据成员置空。这可以防止析构函数多次释放资源（如内存）。

MemoryBlock(MemoryBlock&& other)

   : _data(nullptr)

   , _length(0)

{

    _data = other._data;

    _length = other._length;

    other._data = nullptr;

    other._length = 0;

}

创建移动赋值运算符

定义一个空的赋值运算符，该运算符参数类型为右值引用，返回一个引用类型；
防止将对象赋给自身；
释放目标对象中所有资源（如内存），将数据成员从源对象转移到要构造的对象；
返回对当前对象的引用。

MemoryBlock& operator=(MemoryBlock&& other)

{

    if (this != &other)

    {

        delete[] _data;

        _data = other._data;

        _length = other._length;

        other._data = nullptr;

        other._length = 0;

    }

    return *this;

}

如果同时提供了移动构造函数和移动赋值运算符，则可以编写移动构造函数来调用移动赋值运算符，从而消除冗余代码。

MemoryBlock(MemoryBlock&& other) noexcept

   : _data(nullptr)

   , _length(0)

{

   *this = std::move(other);

}

四、委托构造函数

委托构造函数就是调用同一类中的其他构造函数，完成部分初始化工作。可以在一个构造函数中编写主逻辑，并从其他构造函数调用它。委托构造函数可以减少代码重复，使代码更易于了解和维护。

class Box {

public:

    // 默认构造函数

    Box() {}

    // 构造函数

    Box(int i) :  Box(i, i, i)  // 委托构造函数

    {}

    // 构造函数，主逻辑

    Box(int width, int length, int height)

        : m_width(width), m_length(length), m_height(height)

    {}

};

注意：不能在委托给其他构造函数的构造函数中执行成员初始化

class class_a {

public:

    class_a() {}

    // 成员初始化，未使用代理

    class_a(string str) : m_string{ str } {}

    // 使用代理时不能在此初始化成员，否则会出现以下错误

    // error C3511: a call to a delegating constructor shall be the only member-initializer

    class_a(string str, double dbl) : class_a(str) , m_double{ dbl } {}

    // 其它成员正确的初始化方式

    class_a(string str, double dbl) : class_a(str) { m_double = dbl; }

    double m_double{ 1.0 };

    string m_string;

};

注意：构造函数委托语法能循环调用，否则会出现堆栈溢出。

class class_f{

public:

    int max;

    int min;

    // 这样做语法上允许，但是会在运行时出现堆栈溢出

    class_f() : class_f(6, 3){ }

    class_f(int my_max, int my_min) : class_f() { }

};

五、继承构造函数

派生类可以使用 using 声明从直接基类继承构造函数。一般而言，当派生类未声明新数据成员或构造函数时，最好使用继承构造函数。如果基类的构造函数具有相同签名，则派生类无法从多个基类继承。

#include <iostream>

using namespace std;

class Base

{

public:

    Base() { cout << "Base()" << endl; }

    Base(const Base& other) { cout << "Base(Base&)" << endl; }

    explicit Base(int i) : num(i) { cout << "Base(int)" << endl; }

    explicit Base(char c) : letter(c) { cout << "Base(char)" << endl; }

private:

    int num;

    char letter;

};

class Derived : Base

{

public:

    // 从基类 Base 继承全部构造函数

    using Base::Base;

private:

    // 基类构造函数无法初始化该成员

    int newMember{ 0 };

};

int main()

{

    cout << "Derived d1(5) calls: ";

    Derived d1(5);

    cout << "Derived d1('c') calls: ";

    Derived d2('c');

    cout << "Derived d3 = d2 calls: " ;

    Derived d3 = d2;

    cout << "Derived d4 calls: ";

    Derived d4;

}

/* Output:

Derived d1(5) calls: Base(int)

Derived d1('c') calls: Base(char)

Derived d3 = d2 calls: Base(Base&)

Derived d4 calls: Base()*/

类模板可以从类型参数继承所有构造函数：

template< typename T >

class Derived : T {

    using T::T;   // declare the constructors from T

    // ...

};

构造函数执行顺序

按声明顺序调用基类和成员构造函数。
如果类派生自虚拟基类，则会将对象的虚拟基指针初始化。
如果类具有或继承了虚函数，则会将对象的虚函数指针初始化。虚函数指针指向类中的虚函数表，确保虚函数正确地调用绑定代码。
执行自己函数体中的所有代码。

如果基类没有默认构造函数，则必须在派生类构造函数中提供基类构造函数参数

下面代码，首先，调用基构造函数。然后，按照在类声明中出现的顺序初始化基类成员。最后，调用派生构造函数。

#include <iostream>

using namespace std;

class Contained1 {

public:

    Contained1() { cout << "Contained1 ctor\n"; }

};

class Contained2 {

public:

    Contained2() { cout << "Contained2 ctor\n"; }

};

class Contained3 {

public:

    Contained3() { cout << "Contained3 ctor\n"; }

};

class BaseContainer {

public:

    BaseContainer() { cout << "BaseContainer ctor\n"; }

private:

    Contained1 c1;

    Contained2 c2;

};

class DerivedContainer : public BaseContainer {

public:

    DerivedContainer() : BaseContainer() { cout << "DerivedContainer ctor\n"; }

private:

    Contained3 c3;

};

int main() {

    DerivedContainer dc;

}

输出如下:

Contained1 ctor

Contained2 ctor

BaseContainer ctor

Contained3 ctor

DerivedContainer ctor

参考文章：

构造函数 (C++)

QT学习记录（008）：explicit 关键字的作用

 C++中的explicit详解