一文总结现代 C++ 中的初始化

本文尝试回答:

  • 现代 C++ 有哪几种初始化形式?分别能够用于什么场景?有什么限制?
  • MyClass obj(); 为什么没有调用默认无参构造函数创建一个对象?
  • new intnew int() 有什么区别?
  • 直接初始化、拷贝初始化、列表初始化、默认初始化、值初始化、类内初始值、构造函数初始值列表的区别与联系?
  • 初始化和赋值的区别?
  • 类成员有几种初始化方式,其初始化顺序是由什么决定的?
  • 初始化相关的注意事项及最佳实践?

1. 内置类型和类类型

正式开始介绍初始化之前,先要区分 C++ 中的两种数据类型:内置类型类类型

  • 内置类型:char、bool、short、int、float、double、指针等 C++ 语言支持的最基础的数据类型
  • 类类型:标准库以及我们自己定义的各种类、模板类等,如 MyClassstd::vector<T>std::stringstd::unique_ptr<T>...

2. C++ 初始化的 4 种形式

初始化是指在创建对象(为特定类型的变量申请存储空间)的同时赋予初始值。现代 C++ 中,一共有 4 种初始化形式:

  1. 等号 =...
  2. 等号+花括号 ={...}
  3. 花括号 {...}
  4. 圆括号 (...)

无论是内置类型还是类类型,都支持这 4 种形式的初始化:

int i1=0;   // (1)
int i2={0}; // (2)
int i3{0};  // (3)
int i4(0);  // (4)

std::string s1="hello";   // (1)
std::string s2={"hello"}; // (2)
std::string s3{"hello"};  // (3)
std::string s4("hello");  // (4)

3. 初始化和赋值

前两种初始化虽然在形式上都用了等号 =,但初始化的等号和赋值的等号具有不同的含义。C++ 中赋值和初始化是两种完全不同的操作,只是恰巧都用了等号 =。就好比乘法和解引用都用了 *,含义却完全不同。

  • 初始化:为变量申请存储空间,创建新的变量。如果是类类型,将调用类的构造函数
  • 赋值:把一个现有变量的值用另一个值替代,不创建新的变量。如果是类类型,将调用类的赋值运算符 operator=()
int a = 1; // 初始化
a = 2;     // 赋值

MyClass obj1;              // 初始化,调用 MyClass() 构造函数
MyClass obj2{42, "hello"}; // 初始化,调用 MyClass(int, string) 构造函数
obj1 = obj2;               // 赋值,调用 operator=(const MyClass&)

4. 拷贝初始化和直接初始化

int i1=0;   // (1) 拷贝初始化
int i2={0}; // (2) 拷贝初始化
int i3{0};  // (3) 直接初始化
int i4(0);  // (4) 直接初始化

std::string s1="hello";   // (1) 拷贝初始化
std::string s2={"hello"}; // (2) 拷贝初始化
std::string s3{"hello"};  // (3) 直接初始化
std::string s4("hello");  // (4) 直接初始化

C++ 初始化的 4 种形式中,前两种初始化形式 (1)(2) 使用了等号,叫做拷贝初始化,后两种 (3)(4) 没有等号,叫做直接初始化。无论是拷贝初始化,还是直接初始化,都是初始化,不是赋值!对于类类型,都是调用构造函数,不会调用赋值运算符!在绝大多数情况下(TODO:补充反例),拷贝初始化和直接初始化除了形式上多一个/少一个等号之外,底层代码上没有任何区别。

注意:虽然叫做拷贝初始化,但构造 s1、s2 的过程中,不存在“拷贝”!底层代码和 s3、s4 完全相同,都是直接调用 string 的构造函数(不信可以去 cppinsights.io 自行验证)。

5. 列表初始化

列表初始化(list initialization):使用花括号 {} 形式的初始化。C++ 的 4 种初始化形式中的 (2)(3) 都属于列表初始化。列表初始化在 C++11 中得到全面应用,其最大的特点在于可以防止窄化转换:如果列表初始化存在信息丢失的风险, 编译器将报错。不仅如此,列表初始化还能用于各种初始化场景,包括类内初始值以及 Most Vexing Parse 场景。

a. 防止窄化转换

long double ld = 3.1415;
int a{ld};    // 无法编译,转换存在信息丢失的风险
int b = {ld}; // 无法编译,转换存在信息丢失的风险
int c(ld);    // 可以编译,但信息丢失
int d = ld;   // 可以编译,但信息丢失

b. 避免 Most Vexing Parse

class MyClass {
public:
  MyClass();
  MyClass(int x);
  MyClass(int x, int y);
};

int main() {
  MyClass obj1(1);   // OK
  MyClass obj2{1};   // OK,列表初始化
  MyClass obj3(1,2); // OK
  MyClass obj4(1,2); // OK,列表初始化
  // 错误,obj5 被解析为函数声明:参数为空,返回 MyClass
  MyClass obj5(); 
  MyClass obj6{};  // OK,列表初始化
  MyClass obj7;    // OK
}

注意:obj5 并不是创建一个默认构造的对象,而是被解析为一个函数声明,参数为空,返回 MyClass。有的编译期会给出警告 warning: empty parentheses were disambiguated as a function declaration [-Wvexing-parse]?

6. 默认初始化

默认初始化(default initialization):当对象未被显式地赋予初值时执行的初始化行为。

默认初始化的例子:

int i;
std::string s;
MyClass* p = new MyClass;
double* pd = new double;
  • 类类型:由类的默认(无参)构造决定
  • 内置类型(指针、int、double、float、bool、char 等)及其数组
    • 全局(包括定义在任何函数之外、命名空间之内的)变量或局部静态变量:初始化为 0(这种情况也叫值初始化
    • 局部非静态变量或类成员:未定义(未初始化)

如果类没有默认(无参)构造函数,则该类不支持默认初始化。

7. 值初始化

值初始化(value initialization):默认初始化的特殊情况,此时内置类型会被初始化为 0。

值初始化的场景:

  • STL 容器只指定元素数量,而不指定初值时,就会执行值初始化,如 vector<int> vec(10);:10 个 int,初始化为 0
  • 全局(包括定义在任何函数之外、命名空间之内的)变量或局部静态变量:初始化为 0
  • new 类型,后面带括号,如:new int()new string{}
  • 初始值列表为空 {},如 double d{};int *p{};

类类型没必要区分是默认初始化还是值初始化:类类型的初始化总是由类的构造函数决定,与在函数内/外、全局/局部/类成员、静态/非静态、默认初始化/值初始化无关!如果类不含默认(无参)构造,则该类无法进行默认初始化/值初始化!

8. new 的初始化

// 对于类类型,有无括号没区别
string *ps1 = new string;    // 默认初始化为空 string
string *ps2 = new string();  // 值初始化为空 string
string *ps3 = new string{};  // 值初始化为空 string

// 对于内置类型,有括号进行值初始化,没有括号的值未定义!
int *pi1 = new int;          // 默认初始化,*pi1 值未定义!
int *pi2 = new int();        // 值初始化,*pi2 为 0
int *pi3 = new int{};        // 值初始化,*pi3 为 0

const int *pci1 = new const int(1024); // 分配并初始化一个 const int
const int *pci2 = new const int{1024}; // 分配并初始化一个 const int

9. 类的初始化

类成员有两种初始化方式:类内初始值(成员初始化器,in-class member initializer)以及构造函数初始值列表(constructor initialize list)。

不要在构造函数体内部初始化数据成员,因为只有当类的所有成员初始化完成之后才开始执行构造函数体,此时并不是真正意义上的初始化,而是重新赋值!也正是因为如此,引用成员、const 成员只能通过类内初始值或者构造函数初始值列表初始化,而不能在构造函数体内部“初始化”。不仅如此,在构造函数体内部进行赋值,相比于内类初始值/构造函数初始化列表的只调用一次构造函数,多了一次赋值操作,效率更低。

注意:对于内置类型的数据成员,如果没有对其进行显式初始化,其值未定义!

9.1 类内初始值/成员初始化器

在类中声明类的数据成员同时提供初始值,初始值可以是字面值、表达式甚至是函数调用。形式上可以用等号或者花括号,但是不能用圆括号。C++11 之后首选的初始化类成员方式。

class SalesData {
    unsigned unitsSold = 0;
    double revenue {0.0};
    std::string bookNo{"hello"};
    shared_ptr<int> sp={make_shared<int>(5)};
};

9.2 构造函数初始值列表

如果需要根据传入构造函数的参数来初始化类成员,可以使用构造函数初始值列表。构造函数初始值列表的形式是在构造函数的形参列表之后,使用冒号分隔,接着是成员名字,然后使用圆括号或花括号来包裹初始化的表达式,多个成员之间通过逗号分隔。

class SalesData {
public:
    SalesData(const std::string &s) : bookNo(s) {}
    SalesData(const std::string &s, unsigned n, double p) : bookNo(s), unitsSold(n), revenue(p*n) {}
};

注意:类的数据成员初始化顺序和构造函数初始化列表中的顺序无关,而是由成员在类中声明的顺序决定

class X {
    int x;
    int y;
public:
    // 先用未初始化的 y 初始化 x,再用 val 初始化 y
    X(int val): y(val), x(y){}
};

上述 x 值未定义!一般编译器会给出警告。

9.3 类成员的初始化顺序

类的数据成员初始化顺序由成员在类中声明的顺序决定,按照声明的顺序,依次构造每个成员,所有成员构造完成后才执行构造函数。

顺便说一句,析构顺序与初始化顺序相反:先执行析构函数,再按照构造相反的顺序依次析构每个成员。

10. 总结

现代 C++ 4 种初始化形式:

序号 形式 拷贝/直接初始化 可用于构造函数初始值列表 可用于类内初始值 备注
1 等号 = 拷贝初始化
2 等号+花括号 ={} 拷贝初始化 列表初始化
3 花括号 {} 直接初始化 推荐!列表初始化,能用于各种初始化场景!
4 圆括号 () 直接初始化 存在 Most Vexing Parse 问题、不可用于类内初始值及提供多个初始元素值的列表 vector<string> v("a", "an", "the");
  • 拷贝初始化:使用 = 形式的初始化。
  • 直接初始化:不使用 = 形式的初始化(使用 {}()形式初始化)
  • 列表初始化:使用 {} 形式的初始化,能够用于各种初始化场景,也被称为统一初始化
  • 默认初始化:未显式指定初始值的初始化行为。类类型将调用默认无参构造函数;而内置类型可能被值初始化为 0,也可能未被初始化(值未定义)!
  • 值初始化:默认初始化的特殊情况,对于内置类型,其值将被初始化为 0。
  • 类内初始值/成员初始化器:声明类成员的同时直接提供初值,C++11 之后的首选初始化类成员的方式。
  • 构造函数初始值列表:能够根据传入构造函数的参数进行初始类成员

11. 最佳实践/核心指南

  1. 总是初始化内置类型的变量,如 int i{};。最好使用 auto,因为 auto 会强迫初始化:不提供初始值就无法推导类型。

  2. 推荐使用 {} 统一列表初始化,形式统一,能用于各种场景。

  3. 对于类成员的初始化,优先考虑类内初始值。如果需要根据传入构造函数的参数来初始化成员,可以使用构造函数初始值列表,不要在构造函数体内部对类成员进行赋值。

  4. C++核心指南 C.45:如果只是初始化类的数据成员, 不需要专门定义构造函数,用类内初始值。

  5. C++核心指南 NR.5:不要两步初始化,类的构造函数应该直接完成类的初始化工作,不要把初始化的任务转移/强加给类的用户(例如要求用户在创建一个类的对象后,再额外调用一个 Init() 之类的函数)。

12. 扩展阅读

热门相关:暖君   霸宠天下:腹黑帝君妖娆后   拳罡   锦绣医妃之庶女凰途   唐土万里