现代 C++ 中的初始化

原文链接：https://www.cnblogs.com/tengzijian/p/17964231

本文尝试回答：

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

1. 内置类型和类类型

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

  • 内置类型：char、bool、short、int、float、double、指针等 C++ 语言支持的最基础的数据类型
  • 类类型：标准库以及我们自己定义的各种类、模板类等，如 MyClass、std::vector<T>、std::string、std::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)

C++ 通常会对 (2)(3) 两种形式做相同的处理，除了以下几种特殊情况：

  • (2)不可用于构造函数初始值列表，而(3)可以
  • 使用 auto 自动推导类型时，(2)(3)两种形式推导的结果不同：
    • auto i2 = {0}; // (2) i2 类型推导为 std::initializer_list
    • auto i3 {0}; // (3) i3 类型推导为 int
    • auto m2 = {0,1}; // (2) m2 类型推导为 std::initializer_list
    • auto m3 {0,1}; // (3) error: initializer for variable 'm3' with type 'auto' contains multiple expressions
  • 对于不可拷贝对象（如 thread、atomic），(2)(3)结果不同
    • thread t2={f}; // error: chosen constructor is explicit in copy-initialization
    • thread t3{f}; // ok

验证地址：https://cppinsights.io/s/87c55730

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) 没有等号，叫做直接初始化。无论是拷贝初始化，还是直接初始化，都是初始化，不是赋值！对于类类型，都是调用构造函数，不是赋值运算符！

拷贝初始化最大的限制在于不能用于 explicit 的单参构造函数。除此之外，C++14 和 C++17 在对不可拷贝的类的处理上有些差别：

验证地址：https://cppinsights.io/s/b8dedcd5

  auto i2 = {0}; // (2) i2 类型推导为 std::initializer_list<int>
  auto i3 {0};   // (3) i3 类型推导为 int

  auto m2 = {0,1}; // (2) m2 类型推导为 std::initializer_list<int>
  auto m3 {0,1};   // (3) error: initializer for variable 'm3' with type 'auto' contains multiple expressions

  std::string s1="hello";   // (1) 拷贝初始化，C++14 和 C++17 有细微差别
  std::string s2={"hello"}; // (2) 拷贝初始化
  std::string s3{"hello"};  // (3) 直接初始化
  std::string s4("hello");  // (4) 直接初始化
  
  atomic<int> a1=0;   // (1) C++14 报错：拷贝构造被删除；C++17 可以编译
  atomic<int> a2={0}; // (2)
  atomic<int> a3{0};  // (3)
  atomic<int> a4(0);  // (4)

  // thread t1=f;
  // thread t2={f}; // error: chosen constructor is explicit in copy-initialization
  thread t3{f};
  thread t4(f);

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 类成员的初始化顺序

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

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

9.4 声明时初始化、初始化列表、构造函数初始化

 1 #include "stdafx.h"
 2 #include <iostream>
 3 using namespace std;
 4 class A 
 5 {
 6 public:
 7     int a = 1;
 8     A() {}
 9     A(int a_):a(a_){}
10     A(int a_, bool b) :a(4) { a = a_; }
11 };
12 
13 int main()
14 {
15     A a1, a2(3), a3(5, true);
16     cout << "a1.a=" << a1.a << endl;
17     cout << "a2.a=" << a2.a << endl;
18     cout << "a3.a=" << a3.a << endl;
19     system("pause");
20     return 0;
21 }

结果如图，可看出，初始化列表初始化的变量值会覆盖掉声明时初始化的值，而构造函数中初始化的值又会覆盖掉初始化列表的

成员变量初始化的顺序为：先进行声明时初始化，然后进行初始化列表初始化，最后进行构造函数初始化

初始化列表中初始化的顺序是和变量声明的顺序一样，而与列表中的顺序无关

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. 推荐使用 {} 统一列表初始化，能够避免窄化转化，形式统一，能用于各种场景。（注意：如果类中含有形参为 std::initializer_list 的构造函数，{} 形式会导致编译器强烈地优先选择 std::initializer_list 的重载版本，详见 Effective Modern C++ 条款 7）

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

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

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

12. 扩展阅读

 

posted @ 2024-07-25 17:48  ImreW  阅读(2)  评论(0)  编辑  收藏  举报