构造函数与成员初始化器列表

构造函数 是以一种特殊的声明符语法进行声明的非静态成员函数，它们用来初始化该类类型的对象。

语法

构造函数用以下形式的成员函数声明符声明：

构造函数声明的声明说明符中只允许说明符 friend、inline、constexpr(C++11 起)、consteval(C++20 起) 及 explicit（尤其是不允许返回类型）。注意 cv 及引用限定符也不受允许；const 与 volatile 语义对于构造过程中的对象没有效果，它们要到最终派生类的构造函数完成才会生效。

类名 的标识表达式必须具有以下形式之一：

• 在友元声明中，标识表达式是一个命名了构造函数的有限定的标识符。
• 否则，在属于类或类模板的成员说明的成员声明中：

• 对于类，标识表达式是立即外围类的注入类名。
• 对于类模板，标识表达式是命名了立即外围类模板的当前实例化的类名(C++20 前)立即外围类模板的注入类名(C++20 起)。

• 否则，标识表达式是一个有限定的标识符，并且它尾部的未限定的标识符是在该标识表达式的查找语境中的注入类名。

成员初始化器列表

任何构造函数的函数定义的函数体，可以在复合语句的开花括号之前包含成员初始化器列表，它的语法是冒号字符 : 后随一个或多个成员初始化器 的逗号分隔列表，每项均具有以下语法：

struct S
{
    int n;
    
    S(int);       // 构造函数声明
    
    S() : n(7) {} // 构造函数定义：
                  // ": n(7)" 是初始化器列表
                  // ": n(7) {}" 是函数体
};

S::S(int x) : n{x} {} // 构造函数定义：": n{x}" 是初始化器列表

int main()
{
    S s;      // 调用 S::S()
    S s2(10); // 调用 S::S(int)
}

解释

构造函数没有名字且无法被直接调用。它们在发生初始化时被调用，且它们按照初始化的规则进行选择。没有 explicit 说明符的构造函数是转换构造函数。有 constexpr 说明符的构造函数会让其类型成为字面类型。可以不带任何实参调用的构造函数是默认构造函数。可以接收同类型的另一对象为实参的构造函数是复制构造函数和移动构造函数。

在开始执行组成构造函数体的复合语句之前，所有直接基类、虚基类和非静态数据成员的初始化均已结束。这些对象的非默认初始化只能在成员初始化器列表指定。对于不能默认初始化的基类，和不能以默认初始化或以其默认成员初始化器（如果有）(C++11 起)初始化的非静态数据成员，例如引用和 const 限定的类型的成员，必须指定成员初始化器。（注意，类模板实例化的非静态数据成员的默认成员初始化器，当成员类型或初始化器待决时可能是无效的。)(C++11 起)对没有成员初始化器或默认成员初始化器(C++11 起)的匿名联合体或变体成员不进行初始化。

类或标识符 指名虚基类的初始化器，在并非所构造对象的最终派生类的类的构造期间被忽略。

在表达式列表 或花括号初始化器列表 中出现的名字在构造函数的作用域中求值：

class X
{
    int a, b, i, j;
public:
    const int& r;
    X(int i)
      : r(a) // 初始化 X::r 以指代 X::a
      , b{i} // 初始化 X::b 为形参 i 的值
      , i(i) // 初始化 X::i 为形参 i 的值
      , j(this->i) // 初始化 X::j 为 X::i 的值
    {}
};

成员初始化器所抛出的异常可以被函数 try 块处理。

struct S
{
    int n = 42;   // 默认成员初始化器
    S() : n(7) {} // 将设置 n 为 7，而非 42
};

引用成员不能绑定到成员初始化器列表中的临时量：

struct A
{
    A() : v(42) {} // 错误
    const int& v;
};

注：这同样适用于默认成员初始化器。

在构造和析构期间的操作

可以为正在构造或析构的对象调用成员函数（包括虚成员函数）。正在构造或析构的对象也可以是 typeid 和 dynamic_cast 的操作数。

然而如果在进行以下求值操作的过程中进行这些操作，那么行为未定义：

• 在完成所有基类的成员初始化器 之前对成员初始化器列表求值

class Foo
{
public: 
    Foo(char x, int y) {}
    Foo(int y) : Foo('a', y) {} // Foo(int) 委托到 Foo(char, int)
};

初始化顺序

列表中的成员初始化器的顺序无关紧要，初始化的实际顺序如下：

（注意：如果初始化的顺序是由不同构造函数中的成员初始化器列表中的出现所控制，那么析构函数就无法确保销毁顺序是构造顺序的逆序了。）

注解

示例

#include <fstream>
#include <string>
#include <mutex>

struct Base
{
    int n;
};   

struct Class : public Base
{
    unsigned char x;
    unsigned char y;
    std::mutex m;
    std::lock_guard<std::mutex> lg;
    std::fstream f;
    std::string s;
    
    Class(int x) : Base{123}, // 初始化基类
        x(x),     // x（成员）以 x（形参）初始化
        y{0},     // y 初始化为 0
        f{"test.cc", std::ios::app}, // 在 m 和 lg 初始化之后发生
        s(__func__), //__func__ 可用，因为初始化器列表是构造函数的一部分
        lg (m),   // lg 使用已经初始化的 m
        m{}       // m 在 lg 前初始化，即使它最后出现在此处
    {}            // 空复合语句
    
    Class(double a) : y(a + 1),
        x(y), // x 将在 y 前初始化，它的值不确定
        lg(m)
    {} // 基类初始化器未在列表中出现，它被默认初始化（这与使用 Base() 不同，那是值初始化）
    
    Class()
    try // 函数 try 块在包含初始化器列表的函数体之前开始
      : Class(0.0) // 委托构造函数
    {
        // ...
    }
    catch (...)
    {
        // 初始化中发生的异常
    }
};

int main()
{
    Class c;
    Class c1(1);
    Class c2(0.1);
}

缺陷报告

下列更改行为的缺陷报告追溯地应用于以前出版的 C++ 标准。

引用

参阅

• 复制消除
• 转换构造函数
• 复制赋值
• 复制构造函数
• 默认构造函数
• 析构函数
• explicit
• 初始化
  • 聚合初始化
  • 常量初始化
  • 复制初始化
  • 默认初始化
  • 直接初始化
  • 列表初始化
  • 引用初始化
  • 值初始化
  • 零初始化
• 移动赋值
• 移动构造函数
• new