现代 C++ 中的初始化

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

本文尝试回答:

  • 现代 C++ 有哪几种初始化形式?分别能够用于什么场景?有什么限制?
  • MyClass obj(); 为什么没有调用默认无参构造函数创建一个对象?
  • new int 和 new 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)

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编辑  收藏  举报