构造函数和析构函数 §

构造函数基本职能 §

构造函数主要包括以下职能：

• 内存布局的确定：构造函数所在的类决定了对象的内存布局，包括成员变量的类型和顺序。
• 成员变量的初始化：构造函数负责初始化对象的成员变量。
• 虚表指针的设置：对于包含虚函数的类，构造函数负责设置虚表指针，以支持运行时多态。

构造函数的调用顺序 §

在执行构造时，首先会调用基类的构造函数，然后依次调用成员变量的构造函数，最后执行派生类的构造函数体。

class Base {
public:
    Base() {
        std::cout << "Base constructed" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructed" << std::endl;
    }
};

int main (int argc, char *argv[]) {
    Derived d;
    // 输出：
    // Base constructed
    // Derived constructed
}

可以看到，Derived 隐式地调用了 Base 的默认构造函数。在任何情况下，子类都必须先显式或隐式地调用父类构造函数，才能完成对象的构造。在不显式调用父类构造函数的情况下，编译器会自动调用父类的默认构造函数。

在继承场景下，子类有时需要显式调用父类的构造函数：

class Base {
public:
    Base(int value) : x(value) {}
private:
    const int x;
};

class Derived : public Base {
public:
    Derived(int value) : Base(value) {} // 显式调用父类构造函数
};

class Base {
public:
    Base(int value) : x(value) {}
private:
    int x;
};

class Derived : public Base {
public:
    Derived() {} // error: no matching constructor for initialization of 'Base'
};

class Derived : public Base {
public:
    Derived() : Base(0) {} // 显式调用父类构造函数
};

class Base {
public:
    Base() = default; // 让编译器生成默认构造函数
    Base(int value) : x(value) {}
private:
    int x;
};

成员的初始化 §

C++ 提供了两种初始化成员变量的方式：

• 初始化列表（优先级更高，覆盖类内初始化）；
• 类内初始化（in-class initializers），即在类定义中直接初始化成员变量（C++11 引入的特性）。

class Foo {
public:
    Foo() {};
    Foo(int a, int b) : x(a), y(b) {} // 初始化列表
private:
    const int x = 0;
    const int y = 0;    
}

int x = 5; // 初始化
int y = { 5 }; // 初始化
int z{ 5 }; // 初始化
x = 10; // 赋值

执行初始化时，初始化的顺序与成员变量被定义的顺序一致，而与初始化列表中的初始化器排列顺序无关。 当成员变量的初始化依赖于其他成员变量，这一规则尤为重要，这时需要确保被依赖的成员变量在类定义中出现在依赖它的成员变量之前。例如，下面的写法会导致未定义行为：

class X {
public:
    X(int val) : j(val), i(j) {}
private:
    int i;
    int j;
}

在这个例子中，i 的初始化依赖于 j，因此，j 必须定义在 i 之前。目前，主流的编译器会针对这种情况发出警告：

默认构造函数 §

默认构造函数（default constructor）是指不需要参数的构造函数。在没有定义任何构造函数的类中，编译器会自动生成一个默认构造函数。由编译器自动生成的构造函数称作 合成默认构造函数（synthesized default constructor） 。但是，如果类定义了任何带参构造函数，编译器就不会生成默认构造函数，这时除了显式定义默认构造函数外，还可通过 = default 让编译器生成默认构造函数。

class Foo {
public:
    Foo(const Foo& foo);
private:
    std::string name;
};

int main (int argc, char *argv[]) {
    Foo foo; // error: no matching constructor for initialization of 'Foo'
}

默认构造函数通过如下方式使用：

Foo foo; // 正确，调用默认构造函数
Foo foo(); // 错误，被解析为函数声明

explicit 与隐式转换 §

explicit 关键字用于修饰构造函数，表示该构造函数不能用于隐式类型转换。默认情况下，单参数构造函数可以用于隐式类型转换。例如：

class Foo {
public:
    Foo(int value) : x(value) {}
private:
    int x;
};

void do_something(const Foo& foo) {}

int main() {
    do_something(42); // 正确，隐式将 int 转换为 Foo
}

很多时候，我们并不希望发生隐式转换，例如：

class Resource {
public:
    Resource(int value) : id(value) {}
private:
    int id;
};

void process_resource(const Resource& resource) {}

int main() {
    process_resource(3);
}

我们的本意是通过 process_resource 处理一个已经存在的 Resource 对象，但上面的代码会隐式创建一个临时的 Resource 对象并传递给函数，这样的操作并非我们的本意。为避免这种情况，可以将构造函数声明为 explicit，这样，要创建 Resource 对象，只能显式地调用构造函数：

class Resource {
public:
    explicit Resource(int value) : id(value) {}
private:
    int id;
};

void process_resource(const Resource& resource) {}

int main() {
    Resource res(3); // 正确，显式创建 Resource 对象
    process_resource(res); // 正确，传递已有的 Resource 对象
    process_resource(3); // 错误，不能隐式转换
}

复制构造函数 §

复制构造函数的参数必须是对同类型对象的引用，并且几乎总是 const 引用。之所以必须是引用类型，是因为如果传递的是值类型，则会调用复制构造函数来创建参数对象，从而导致无限递归。

复制构造函数（若有）几乎不可避免地要在隐式转换中被调用，因此复制构造函数不应该声明为 explicit，例如：

class Foo {
public:
    Foo(const Foo& other) : x(other.x) {}
private:
    int x;
};

void do_something(Foo foo) {}

int main() {
    Foo foo1;
    do_something(foo1);
}

在不考虑编译优化的情况下，调用 do_something 时，foo1 实际上会先被复制一份（隐式调用复制构造函数）并作为参数传递，因此，复制构造函数的隐式调用几乎是不可避免的。

默认情况下，编译器会自动生成一个复制构造函数，称作 合成复制构造函数（synthesized copy constructor） ，其行为是逐成员复制（member-wise copy）。实际开发中，若需要用到复制构造函数（即不标记为 = delete），则应总是显示定义复制构造函数（自行定义或使用 = default）。

移动构造函数 §

移动构造函数用于实现资源的移动语义，用于在资源所有权可转移的情况下替代复制构造函数，从而提高性能。移动构造函数总是只包含简单的资源所有权转移操作，因此常常标记为 noexcept。

class Foo {
public:
    Foo(Foo&& other) noexcept : x(other.x) {
        other.x = nullptr; // 转移资源所有权
    }
private:
    int* x;
};

与复制构造函数类似，若需要用到移动构造函数（即不标记为 = delete），则应总是显示定义移动构造函数（自行定义或使用 = default）。

委托构造函数 §

C++11 引入了委托构造函数（delegating constructor）的概念，允许一个构造函数调用 同一类中的另一个构造函数 ，从而实现代码复用。例如：

class Foo {
public:
    Foo(int value) : x(value) {}
    Foo() : Foo(0) {} // 委托构造函数
private:
    int x;
};

constexpr 构造函数 §

提供 constexpr 构造函数的类可以形成字面类，即可以在编译期完成构造：

class Foo {
    int bar;
    constexpr Foo(int bar) : bar(bar) {}
};

constexpr Foo foo(1);

异常 §

若在构造函数中抛出了异常，由于对象没有被完全构造，因此析构函数不会被调用。因此，若必须在构造函数中抛出异常，必须保证申请的资源正确释放。

析构函数的调用顺序 §

与对象构造顺序相反，对象析构时，首先会执行派生类的析构函数体，然后依次调用成员变量的析构函数，最后调用基类的析构函数。

对于存在虚函数的类，析构函数 必须 也定义为虚函数。通过指针析构基类对象时，若基类析构函数不是虚函数，则只会调用基类的析构函数，而不会调用派生类的析构函数，从而导致资源泄漏。

class Base {
public:
    Base() {
        std::cout << "Base constructed" << std::endl;
    }
    ~Base() {
        std::cout << "Base destructed" << std::endl;
    }
};

class Derived : public Base {
public:
    Derived() {
        std::cout << "Derived constructed" << std::endl;
    }
    ~Derived() {
        std::cout << "Derived destructed" << std::endl;
    }
};

int main (int argc, char *argv[]) {
    Derived d; // 析构时 Derived 和 Base 的析构函数都会被调用
    Base* b = new Derived;
    delete b; // 只会调用 Base 的析构函数，导致 Derived 的资源泄漏
}

异常 §

析构函数 严禁 抛出异常，任何析构函数必须标记为 noexcept。