构造函数是类的一种特殊的非静态成员函数，用于初始化该类类型的对象。

在类的构造函数定义中，成员初始化器列表指定各个直接和虚基类子对象和各个非静态数据成员的初始化器。（请勿与 std::initializer_list 混淆）

语法

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

其中 类名 必须指名当前类（或类模板的当前实例化），或当在命名空间作用域或在友元声明中声明时，它必须是有限定的类名。

构造函数声明的 声明说明符序列 中仅允许说明符 friend、inline、explicit 及 constexpr（尤其是不允许返回类型）。注意 cv 及引用限定符也不受允许；const 与 volatile 语义对于构造过程中的对象无效果，直至最终派生类的构造函数完成才生效。

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

1) 用直接初始化，或当 表达式列表 为空时用值初始化，初始化 类或标识符 所指名的基类或成员

2) 用列表初始化（若列表为空则为值初始化，而在初始化聚合体时为聚合初始化），初始化 类或标识符 所指名的基类或成员

3) 用包展开初始化多个基类

运行此代码

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 说明符的构造函数令其类型成为字面类型 (LiteralType) 。可以不带任何实参调用的构造函数是默认构造函数。可以接收同类型的另一对象为实参的构造函数是复制构造函数和移动构造函数。

在开始执行组成构造函数体的复合语句之前，所有直接基类，虚基类，及非静态数据成员的初始化均已结束。成员初始化器列表是能指定这些对象的非默认初始化之处。对于不能默认初始化的成员，例如引用和 const 限定的类型的成员，必须指定成员初始化器。对没有成员初始化器的匿名联合体或变体成员不进行初始化。

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

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

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 块处理。

成员函数（包括虚成员函数）可从成员初始化器调用，但若在该点所有直接基类尚未全部被初始化，则行为未定义。

对于虚函数调用（若基类已被初始化），适用与从构造函数与析构函数中进行虚函数调用相同的规则：虚成员函数表现如同 *this 的动态类型是正在构造的类（动态派发不在继承层级下传），而对纯虚成员函数的虚调用（但非静态调用）是未定义行为。

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

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

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

初始化顺序

列表中的成员初始化器的顺序是不相关的：初始化的实际顺序如下：

1) 若构造函数是最终派生类的，则按基类声明的深度优先、从左到右的遍历中的出现顺序（从左到右指的是基说明符列表中所呈现的），初始化各个虚基类

2) 然后，以在此类的基类说明符列表中出现的从左到右顺序，初始化各个直接基类

3) 然后，以类定义中的声明顺序，初始化各个非静态成员。

4) 最后，执行构造函数体

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

示例

运行此代码

#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++ 标准。

引用

• C++11 standard (ISO/IEC 14882:2011):

• • 12.1 Constructors [class.ctor]

• • 12.6.2 Initializing bases and members [class.base.init]

• C++98 standard (ISO/IEC 14882:1998):

• • 12.1 Constructors [class.ctor]

• • 12.6.2 Initializing bases and members [class.base.init]