本文尝试回答：
- 现代 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 种初始化形式：
- 等号
=... - 等号+花括号
={...} - 花括号
{...} - 圆括号
(...)
无论是内置类型还是类类型，都支持这 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. 最佳实践/核心指南
-
总是初始化内置类型的变量，如
int i{};。最好使用 auto，因为 auto 会强迫初始化：不提供初始值就无法推导类型。 -
推荐使用
{}统一列表初始化，形式统一，能用于各种场景。 -
对于类成员的初始化，优先考虑类内初始值。如果需要根据传入构造函数的参数来初始化成员，可以使用构造函数初始值列表，不要在构造函数体内部对类成员进行赋值。
-
C++核心指南 C.45：如果只是初始化类的数据成员， 不需要专门定义构造函数，用类内初始值。
-
C++核心指南 NR.5：不要两步初始化，类的构造函数应该直接完成类的初始化工作，不要把初始化的任务转移/强加给类的用户（例如要求用户在创建一个类的对象后，再额外调用一个
Init()之类的函数）。