初始值设定项

项目
06/09/2015

初始值设定项可指定变量的初始值。你可以在以下上下文中初始化变量：

在变量的定义中：
```
int i = 3;
Point p1{ 1, 2 };
```
作为函数的一个参数：
```
set_point(Point{ 5, 6 });
```

作为函数的返回值：

Point get_new_point(int x, int y) { return { x, y }; }
Point get_new_point(int x, int y) { return Point{ x, y }; }

初始值设定项可以采用以下形式：

括号中的表达式（表达式的逗号分隔列表）：
```
Point p1(1, 2);
```
等号后跟表达式：
```
string s = "hello";
```

括号内的初始值设定项列表。该列表可能为空，或可能包含一组列表：

struct Point{
    int x;
    int y;
};
class PointConsumer{
public:
    void set_point(Point p){};
    void set_points(initializer_list<Point> my_list){};
};
int main() {
    PointConsumer pc{};
    pc.set_point({});
    pc.set_point({ 3, 4 });
    pc.set_points({ { 3, 4 }, { 5, 6 } });
}

初始化类型

初始化有若干类型，可能出现在程序执行的不同点。不同的初始化类型并不是相互排斥的。例如，列表初始化可触发值初始化，在其他情况中，它可以触发聚合初始化。

零初始化

零初始化是指将变量设置为隐式转换为该类型的零值：

数值变量初始化为 0（或 0.0、0.0000000000 等）。
字符变量初始化为“\0”。
指针初始化为 nullptr。
数组、POD 类、结构和联合将其成员初始化为零值。

零初始化在不同的时间执行：

在程序启动时，对具有静态持续时间的所有已命名变量进行初始化。这些变量可以稍后再次初始化。
值初始化期间，对使用空大括号初始化的标量类型和 POD 类类型进行初始化。
对只有部分成员初始化的数组进行初始化。

以下是零初始化的一些示例：

struct my_struct{
    int i;
    char c;
};

int i0;              // zero-initialized to 0
int main() {
    static float f1;  // zero-initialized to 0.000000000
    double d{};     // zero-initialized to 0.00000000000000000
    int* ptr{};     // initialized to nullptr
    char s_array[3]{'a', 'b'};  // the third char is initialized to '\0'
    int int_array[5] = { 8, 9, 10 };  // the fourth and fifth ints are initialized to 0
    my_struct a_struct{};   // i = 0, c = '\0'
}

默认初始化

类、结构和联合的默认初始化使用默认构造函数。通过不包括初始化表达式或通过使用 new 关键字可调用默认构造函数：

MyClass mc1;
MyClass* mc3 = new MyClass;

如果类、结构或联合没有默认构造函数，则编译器将发出错误。

如果定义标量变量时不使用初始化表达式，则进行默认初始化。它们的值是不确定的。

int i1;
float f;
char c;

如果定义数组时不使用初始化表达式，则进行默认初始化。数组进行默认初始化时，其成员将进行默认初始化并具有不确定的值：

int int_arr[3];

如果数组成员没有默认构造函数，则编译器将发出错误。

常量变量的默认初始化

常量变量必须与初始值设定项一起声明。如果它们是标量类型，则会导致编译器错误，而如果是具有默认构造函数的类类型，则将导致警告：

class MyClass{};
int main() {
    //const int i2;   // compiler error C2734: const object must be initialized if not extern
    //const char c2;  // same error
    const MyClass mc1; // compiler error C4269: 'const automatic data initialized with compiler generated default constructor produces unreliable results
}

静态变量的默认初始化

如果静态变量的声明中没有初始值设定项，则初始化为 0（隐式转换为该类型）：

class MyClass {   
private:
    int m_int;
    char m_char;
};

int main() {
    static int int1;       // 0
    static char char1;     // '\0'
    static bool bool1;   // false
    static MyClass mc1;     // {0, '\0'}
}

有关全局静态对象初始化的详细信息，请参阅附加启动注意事项。

值初始化

值初始化发生在以下情况下：

使用空大括号初始化来初始化已命名值。
使用空圆括号或大括号初始化匿名临时对象。
使用 new 关键字和空圆括号或大括号来初始化对象。

值初始化执行以下操作：

对于至少有一个公共构造函数的类，将调用默认构造函数。
对于没有声明构造函数的非联合类，该对象进行零初始化，并调用默认构造函数。
对于数组，每个元素都进行值初始化。
在其他所有情况下，变量进行零初始化。

class BaseClass {  
private:
    int m_int;
};

int main() {
    BaseClass bc{};     // class is initialized
    BaseClass*  bc2 = new BaseClass();  // class is initialized, m_int value is 0
    int int_arr[3]{};  // value of all members is 0
    int a{};     // value of a is 0
    double b{};  // value of b is 0.00000000000000000
}

复制初始化

复制初始化是指使用一个对象来初始化另一个对象。它发生在以下情况下：

使用等号初始化变量。
参数传递给函数。
从函数返回对象。
引发或捕获异常。
使用等号初始化非静态数据成员。
在聚合初始化期间通过复制初始化来初始化类、结构和联合成员。请参阅聚合初始化中的示例。

以下代码将显示复制初始化的示例：

#include <iostream>
using namespace std;

class MyClass{
public:
    MyClass(int myInt) {}
    void set_int(int myInt) { m_int = myInt; }
    int get_int() const { return m_int; }
private:
    int m_int = 7; // copy initialization of m_int

};
class MyException : public exception{};
int main() {
    int i = 5;              // copy initialization of i
    MyClass mc1{ i };
    MyClass mc2 = mc1;      // copy initialization of mc2 from mc1
    MyClass mc1.set_int(i);    // copy initialization of parameter from i
    int i2 = mc2.get_int(); // copy initialization of i2 from return value of get_int()

    try{
        throw MyException();    
    }
    catch (MyException ex){ // copy initialization of ex
        cout << ex.what();  
    }
}

复制初始化不能调用显式构造函数：

vector<int> v = 10; // the constructor is explicit; compiler error C2440: cannot convert from 'int' to 'std::vector<int,std::allocator<_Ty>>'
regex r = "a.*b"; // the constructor is explicit; same error
shared_ptr<int> sp = new int(1729); // the constructor is explicit; same error

有时，如果类的复制构造函数被删除或不可访问，复制初始化将导致编译器错误。有关详细信息，请参阅显式初始化。

直接初始化

直接初始化使用（非空）大括号或圆括号。不同于复制初始化，它可以调用显式构造函数。它发生在以下情况下：

使用非空大括号或圆括号初始化变量。
使用 new 关键字和非空大括号或圆括号来初始化变量。
使用 static_cast 初始化变量。
在构造函数中，使用初始值设定项列表初始化基类和非静态成员。
lambda 表达式中捕获的变量的副本中。

以下是直接初始化的示例：

class BaseClass{
public:
    BaseClass(int n) :m_int(n){} // m_int is direct initialized
private:
    int m_int;
};

class DerivedClass : public BaseClass{
public:
    // BaseClass and m_char are direct initialized
    DerivedClass(int n, char c) : BaseClass(n), m_char(c) {}
private:
    char m_char;
};
int main(){
    BaseClass bc1(5);
    DerivedClass dc1{ 1, 'c' };
    BaseClass* bc2 = new BaseClass(7);
    BaseClass bc3 = static_cast<BaseClass>(dc1);

    int a = 1;
    function<int()> func = [a](){  return a + 1; }; // a is direct initialized
    int n = func();
}

列表初始化

使用大括号内的初始值设定项列表初始化变量时，将发生列表初始化。大括号内的初始值设定项列表可在以下情况中使用：

初始化变量。
使用 new 关键字初始化类。
从函数返回对象。
参数传递给函数。
直接初始化中的参数之一。
在非静态数据成员的初始值设定项中。
在构造函数初始值设定项列表中。

列表初始化的示例：

class MyClass {
public:
    MyClass(int myInt, char myChar) {}  
private:
    int m_int[]{ 3 };
    char m_char;
};
class MyClassConsumer{
public:
    void set_class(MyClass c) {}
    MyClass get_class() { return MyClass{ 0, '\0' }; }
};
struct MyStruct{
    int my_int;
    char my_char;
    MyClass my_class;
};
int main() {
    MyClass mc1{ 1, 'a' };
    MyClass* mc2 = new MyClass{ 2, 'b' };
    MyClass mc3 = { 3, 'c' };

    MyClassConsumer mcc;
    mcc.set_class(MyClass{ 3, 'c' });
    mcc.set_class({ 4, 'd' });

    MyStruct ms1{ 1, 'a', { 2, 'b' } };
}

聚合初始化

聚合初始化是针对数组或类类型（通常为结构或联合）的一种列表初始化形式：

没有私有或受保护成员。
没有用户提供的构造函数，显式默认或删除的构造函数除外。
没有基类。
没有虚拟成员函数。
没有用于非静态成员的大括号或等号初始值设定项。

聚合初始值设定项包括含等号或不含等号的括号内的初始化列表：

#include <iostream>
using namespace std;

struct MyAggregate{
    int myInt;
    char myChar;
};

int main() {
    MyAggregate agg1{ 1, 'c' };

    cout << "agg1: " << agg1.myChar << ": " << agg1.myInt << endl;
    cout << "agg2: " << agg2.myChar << ": " << agg2.myInt << endl;

    int myArr1[]{ 1, 2, 3, 4 };
    int myArr2[3] = { 5, 6, 7 };
    int myArr3[5] = { 8, 9, 10 };

    cout << "myArr1: ";
    for (int i : myArr1){
        cout << i << " ";
    }
    cout << endl;
    
    cout << "myArr3: ";
    for (auto const &i : myArr3) {
        cout << i << " ";
    }
    cout << endl;
}

这是输出：

agg1: c: 1
agg2: d: 2
myArr1: 1 2 3 4
myArr3: 8 9 10 0 0

重要

在聚合初始化期间声明但未显式初始化的数组成员将进行零初始化，如 myArr3 中。

初始化联合和结构

如果联合没有构造函数，你可以使用值（或使用联合的另一个实例）对其初始化。该值用于初始化第一个非静态字段。结构初始化与其不同，其初始值设定项中的第一个值用于初始化第一个字段，第二个值用于初始化第二个字段，依此类推。比较下例中联合和结构的初始化：

struct MyStruct {
    int myInt;
    char myChar;
};
union MyUnion {
    int my_int;
    char my_char;
    bool my_bool;
    MyStruct my_struct;
};

int main() {  
    MyUnion mu1{ 'a' };  // my_int = 97, my_char = 'a', my_bool = true, {myInt = 97, myChar = '\0'}
    MyUnion mu2{ 1 };   // my_int = 1, my_char = 'x1', my_bool = true, {myInt = 1, myChar = '\0'}
    MyUnion mu3{};      // my_int = 0, my_char = '\0', my_bool = false, {myInt = 0, myChar = '\0'}
    MyUnion mu4 = mu3;  // my_int = 0, my_char = '\0', my_bool = false, {myInt = 0, myChar = '\0'}
    //MyUnion mu5{ 1, 'a', true };  // compiler error: C2078: too many initializers
    //MyUnion mu6 = 'a';            // compiler error: C2440: cannot convert from 'char' to 'MyUnion'
    //MyUnion mu7 = 1;              // compiler error: C2440: cannot convert from 'int' to 'MyUnion'

    MyStruct ms1{ 'a' };            // myInt = 97, myChar = '\0'
    MyStruct ms2{ 1 };              // myInt = 1, myChar = '\0'
    MyStruct ms3{};                 // myInt = 0, myChar = '\0'
    MyStruct ms4{1, 'a'};           // myInt = 1, myChar = 'a'
    MyStruct ms5 = { 2, 'b' };      // myInt = 2, myChar = 'b'
}

初始化包含聚合的聚合

聚合类型可包含其他聚合类型，例如数组的数组、结构的数组等。这些类型使用嵌套的大括号组进行初始化：

struct MyStruct {
    int myInt;
    char myChar;
};
int main() {
    int intArr1[2][2]{{ 1, 2 }, { 3, 4 }};
    int intArr3[2][2] = {1, 2, 3, 4};  
    MyStruct structArr[]{ { 1, 'a' }, { 2, 'b' }, {3, 'c'} };
}

引用初始化

有关引用初始化的信息，请参阅初始化引用。

外部变量的初始化

自动变量、寄存器变量、静态变量和外部变量的声明可包含初始值设定项。但是，仅当外部变量没有声明为 extern 时，其声明中才可以包含初始值设定项。有关详细信息，请参阅External。

请参见

参考

声明符

通过