C++11中的变量初始化

淩亂°似流年 2022-09-29 06:36 234阅读 0赞

# 出处：http://www.cnblogs.com/neooelric/p/5828027.html    #

变量初始化很简单嘛，有什么难的？

打住，不要骄傲，往下看，你会哭的。

请看下面四个问题：

1: 下面的语句有不同吗？不同在哪里？

widget w;                   // a

widget w();                 // b

widget w\{\};                 // c

widget w(x);                // d

widget w\{x\};                // e

widget w = x;               // f

widget w = \{x\};             // g

auto w = x;                 // h

auto w = widget\{x\};         // i

2: 下面两行语句分别作了什么？

vector<int> v1(10, 20);     // a

vector<int> v2\{10, 20\};     // b

3: 经过第一题与第二题的洗礼，请你告诉我用\{\}来初始化对象有什么好处？

4: 什么情况下应该用()，什么情况下应该用\{\}，请辩证撕逼！

我知道当你看到第一题的时候已经想把<C++ Primer>撕了糊墙了。

但糊墙之前至少死个明白，弄清楚这四个题的（参考）答案是什么。

解答如下：

在公布答案之前，首先要明白为什么我要提这四个问题。

看起来这只是一个关于茴字到底有几种写法的酸臭题，屏幕面前的观众至少有30%的人会认为这TM有什么用？老子天天写带class的C也挣工资，破语言细节挖那么细有什么用？

请剩下的70%的同学，和我一起对上面提到的30%的人竖起中指。 fucking pussy!

上面的四道题，其实有以下考量:

1: 弄清楚默认初始化，直接初始化，拷贝初始化，列表初始化四种初始化方式的异同

2: 弄清楚用()初始化与用\{\}初始化的异同

3: 上面问题中的代码中，有一行根本不是初始化！

搞清楚这四道题的终极目标是总结出简洁的定律（在第四题的答案中），彻底搞清楚有关初始化的一切。

下面，解答正式开始。

第一题：

widget w;

这是标准的默认初始化。

这条语句声明了一个变量，其名为w，其类型为widget。

1: 对于大多数情景，该变量被默认构造函数widget::widget()所构造。

2: 若widget是一个内置类型，则w未被初始化，其值是未定义的

3: 若widget是一个简陋的类，那么w将被由编译器生成的默认构造函数所构造。

所谓简陋，是指：widget没有显式声明定义任何构造函数

widget w();

这是一个屎坑，来自于C++臭名昭著的“历史原因”。在现代C++项目中，应极力避免这种写法。

直观上看，这好像也是一个初始化语句，声明了一个变量，其名为w，其类型为widget，并显式的调用了widget的无参（默认）构造函数widget::widget()

但其实并不是。注意看下面的语句

int func();

看三遍。

请告诉我，你觉得这是什么？

对的，这是一个函数声明，显然

widget w();

也是一个函数声明。是的，如果一条语句看起来像是一个函数声明，那么你不能假定编译器不会认为这是一个函数声明。

事实上，这个屎坑每天都被无数人踩来踩去，注意看下面的代码，这在实际项目中也是非常频繁出现的写法：

// 注意， gadget和doodad是两个类型名

widget w( gadget(), doodad() );

你以为你初始化并构造了w，但事实上，你写的是一个函数声明。。

不信？敲下面的代码试试：

\#include <iostream>

struct A \{ int a; \};

struct B \{ int b; \};

class C \{

public:

int a;

int b;

public:

C(A a, B b) : a(a.a), b(b.b) \{ \}

\};

C c1(A(), B());             // 这被编译器认为是一个函数声明

C c2\{ A(), B() \};           // 这被编译器认为是一个全局变量的声明+初始化

int main(void) \{

std::cout << c1.a << c1.b << std::endl;     // 编译错误提示应该在这一行，因为c并不是一个C实例，所以没有.a成员

std::cout << c2.a << c2.b << std::endl;

system("pause");

return 0;

在C++11中，你不应该写出这种有二义性的语句。

widget w\{\};

这是一个清晰的，令人愉悦的，没有任何二义性的，初始化语句。

这就是使用\{\}来进行初始化所带来的第一个好处：用\{\}来替代()，变量声明初始化就是声明初始化，函数声明就是函数声明，大家井水不犯河水！

这条语句：声明了一个变量，其名为w，其类型为widget，该变量使用widget的默认构造函数widget::widget()构造

有好事者，言道：“非也！非也！如果widget有一个参数为std::initializer\_list的构造函数，难道这条语句不会导致编译器调用那个构造函数吗？”

不，并不会，C++11标准中明确了，当\{\}内容为空时，将调用默认构造函数。

widget w(x);

widget w\{x\};

这两行是直接初始化，上面我们谈到的都是默认初始化。

大家有没有想过，为什么叫“直接”初始化呢？

因为，假定x不是一个类型名，那么上面两行都是显式的构造函数调用语句，逻辑上效果是widget::widget(x)。

这里，有两点需要注意

1: 且当x恰好就是widget的实例时，将调用拷贝构造函数。

2: 当使用\{x\}形式时，如果widget定义了一个参数类型为initializer\_list的构造函数，那么将调用这个构造函数。

如果widget并没有定义这样的构造函数，那么将调用最可能被调用的那个构造函数

之所以说最可能，是因为传递参数给函数调用，实参类型并不一定需要精确匹配形参类型，x可能会经过一次类型转换

那么，这两种写法有什么区别呢？

区别1:

widget w(x); 这种写法还是有歧义的，当x恰好还是一个类型名时，即使在当前作用域有一个变量名也是x，这种写法还会被认为是一个函数声明

widget w\{x\}; 这种写法永远不会被认为是函数声明

区别2:

widget w\{x\}; 的类型检查与类型转换将更严格，这种写法不允许有精度损失的类型转换，如下所示：

int i1( 12.3456 );          // 正确，因为()写法允许精度丢失的类型转换

int i2\{ 12.3456 \};          // 错误，因为\{\}的写法不允许类型转换时出现精度丢失

widget w = x;

widget x = \{x\};

这两行都是拷贝初始化，前者是拷贝初始化，后者是拷贝列表初始化

这两行语句将调用widget的拷贝构造函数或移动构造函数（不知道移动构造函数为何物的，请参阅中文版<C++ Primer>第五版13.6节，470页，英文版531页）

注意：既然是调用构造函数，那么就可能存在隐式的参数类型转换！

这里再老生常谈一个注意点，请将下面这句话念三遍：

这不是赋值！这不是赋值！这不是赋值！

是的，这两行语句中有=操作符出现，但这真的不是赋值，这是初始化！

初始化调用的是构造函数，即widget::widget(x)，而赋值调用的是赋值操作符，是widget::operator=(x)

如果真的不明白为什么里出现了=但不是赋值，请翻书温习基础。

下面是要注意的点：

1: 如果x恰好是widget的对象，那么就是直接调用拷贝构造函数或者移动构造函数，两行语句效果一致。

2: 对于widget w = x;而言，如果x并不是widget的对象，！！！理论上！！！，将执行下面的步骤

1: 编译器首先用x初始化并构造一个widget类型的临时变量，其构造动作相当于直接初始化，类似于下面的语句

widget temp\{x\};

需要注意的是，编译器构造的这个临时变量其实是一个右值变量

2: 然后编译器将使用这个右值变量，试图调用widget的移动构造函数，临时右值变量阅后即焚，如果没有移动构造函数，将调用拷贝构造函数。

如果存在从x到widget的隐式转换，那么widget w = x的效果等同于widget w(widget(x));

注意，这只是理论上的步骤，实际实现上，编译器到底怎么做的，并不确定。在存在类型转换操作符的情况下，可能直接一步到位使用隐式类型转换，只调用一次构造函数。

类似于

widget temp(widget(x));  // 注意，内层的widget(x)是对类型转换操作符的调用

唯一确定的就是：这两行语句都将调用拷贝构造函数或移动构造函数，并且无论如何，请保持拷贝构造函数是存在的，可用的。

而对于widget x = \{x\};而言，这叫做拷贝列表初始化。实际上效果和widget w\{x\};一毛一样，没有任何区别。

auto w = x;

auto w = widget\{x\};

这两行也是拷贝初始化，但更容易理解一点。

并且对于auto w = widget\{x\};来讲，无论从x到widget是显式的转换，还是隐式的转换，效果都是相同的。

注意点：

1: auto w = x;妥妥的调用拷贝构造函数，因为w的类型是推断出来的，所以变成了下面这种

type\_of\_x w = x; ===> type\_of\_x w(x);

2: auto w = widget\{x\};注意\{\}将搞一个initializer\_list出来，所以如果存在参数为initializer\_list的构造函数，这个构造函数将被优先调用

3: 对于auto w = widget\{x\};来讲，如果x就是widget类型的对象，那么只会调用一次构造函数，优先调用移动构造函数，无移动构造函数将调用拷贝构造函数，效果等同于

widget w = widget\{x\}; ===> widget w\{x\};

而如果x并不是widget类型的对象，那么就势必会发生类型转换，！！！理论上！！！将调用两次构造函数，实际上调用几次我们不得而知，依赖于编译器的具体实现

这是最具C++11的写法，也是最推荐的写法，也就是说，在用C++11的项目中，如果需要用一个对象x，去初始化一个变量w，那么最推荐这种写法

1: 如果w的类型和x一致，那么请使用

auto w = x;

类型推断将保证w与x类型一致，带来的后果就是肯定会调用拷贝构造函数

2: 如果w的类型和x并不一致，那么请使用

auto w = type\_of\_w\{x\};

等号右边保证了无论是显式类型转换还是隐式类型转换，行为都是一致的，无需考虑转换到底是显式的还是隐式的。

关于类型转换的“显式”和“隐式”，请未看过C++11的同学参考中文版<C++ Primer>第五版14.9节，514页，英文版579页

上文中凡是提到类型转换的部分，对类类型而言，隐式类型转换都指普通的类型转换操作符重载，显式类型转换指带explict关键字的类型转换操作符重载

关于第一题的小总结：

1: 默认初始化，请使用下面的写法

type w;

请抛弃下面的写法

type w();

2: 构造的原料与期待的产品类型相同的情况下进行直接初始化，请使用下面的写法

type w\{x\};

auto w = x;

并至少保证拷贝构造函数可用

3: 构造的原料与期待的产品类型不同的情况下，请使用下面的写法

auto w = type\_of\_w\{x\};

保险起见，请保证：

1: 从type\_of\_x到type\_of\_w的（拷贝）构造函数可用

2: 从type\_of\_w到type\_of\_w的拷贝构造函数可用

3: 从type\_of\_x到type\_of\_w的类型转换操作符可用

第二题：

vector<int> v1(10, 20);  调用的是  vector( size\_t n, const int& value );

vector<int> v2\{10, 20\};  调用的是  vector( initializer\_list<int> values );

这两个语句都调用了构造函数，都是直接初始化的语法。

纠结的点在于，vector有多个构造函数，且有两个构造函数符合两个实参的调用，那么，何种情况下调用哪个构造函数呢？

规则如下：

1: \{/\* 至少两个参数 \*/\}语法将搞出一个initializer\_list

2: 形参为initializer\_list的构造函数，将优先于普通参数列表的构造函数被调用

所以：

vector<int> v1(10, 20);

assert(v1.size() == 10);

vector<int> v2\{10, 20\};

assert(v2.size() == 2);

第三题：

使用\{\}是更严格的语法，没有二义性，使用\{\}的初始化可被称为“具有一致性的初始化语法”

所谓一致性是指：

1: 对于所有类型，都可以使用\{\}语法，语法层面上是统一的。包括简单的聚合结构体，数组，标准库容器，以及普通的类

2: 没有二义性，说这是一个初始化，这TM就是一个初始化！！！这不是函数声明！

下面是一致性美学欣赏时间：

struct mystruct \{ int x, y, z; \};

// C++98中的糊屎语法

rectangle           w( origin(), extents() );           // 函数声明？初始化？分不清

complex<double>     c( 2.71828, 3.1415926 );            // 没有毛病

mystruct            m = \{1, 2\};                         // 没有毛病

int                 a\[\] = \{1, 2, 3, 4\};                 // 没有毛病

vector<int>         v;                                  // 有毛病，为了初始化一个简单的向量，竟然要写两行！不能忍！

for(int i = 0; i < 4; ++i) v.push\_back(i);

// 总的来看，初始化语法乱七八糟一锅粥

// C++11里的一致性美感

rectange            w   = \{ origin(), extents() \};      // 漂亮

complex<double>     c   = \{ 2.71828, 3.14159 \};         // 美

mystruct            m   = \{ 1, 2 \};                     // 赏心悦目

int                 a\[\] = \{ 1, 2, 3, 4 \};               // 简直享受

vector<int>         v   = \{ 1, 2, 3, 4 \};               // 啊。。长江。。啊。。黄河！

其实，你或许会说美感都是红粉骷髅，没啥意思，那么你看看下面的泛型代码（看不懂拉倒，我知道很多人并不了解泛型模板，包括我（译者）在内）

template<typename T, typename ...Args>

void forwarder( Args&&... args ) \{

// ...

T local = \{ std::forward<Args>(args)... \};

// ...

forwarder<int>            ( 42 );                  // ok

forwarder<rectangle>      ( origin(), extents() ); // ok

forwarder<complex<double>>( 2.71828, 3.14159 );    // ok

forwarder<mystruct>       ( 1, 2 );                // 错误

forwarder<int\[\]>          ( 1, 2, 3, 4 );          // 错误

forwarder<vector<int>>    ( 1, 2, 3, 4 );          // 错误

并且，并且，一致性到了成员初始化器都可以使用\{\}语法

widget::widget(/\* ... \*/) : mem1\{init1\}, mem2\{init2, init3\} \{ /\* ... \*/ \}

并且，在函数调用传递参数、返回值方面，\{\}也能带给你很多便利

void draw\_rect(rectangle);

draw\_rect(rectangle(origin, selection));            // C++98

draw\_rect(\{origin, selection\});                     // C++11

rectangle compute\_rect() \{

// \*\*

if(cpp98)

return rectangle(origin, selection);        // C++98

else

return \{origin, selection\};                 // C++11

第四题：

0: 调用默认构造函数，你应该始终使用\{\}，例如：

widget w\{\};

1: 要用多个参数搞定的初始化，你应该始终使用\{\}，例如：

vector<int> v = \{1,2,3,4\};

auto v = vector<int>\{1,2,3,4\};

因为\{\}有上面说过的很多好处，诸如简洁，没有二义性等

2: 只用一个参数就能搞定的初始化，你可以省略掉\{\}，转而使用=，例如：

int i = 42;

auto x = anything;

当然，强迫症患者可以从一而终，始终使用\{\}，例如：

int i\{42\};

auto x\{anything\};

3: 只有需要调用特定的构造函数时，才需要在初始化中使用()，如：

vector<int> v1(10, 20);

auto v2 = vector<int>(10, 20);

最后一点注意：当你设计一个类时，尽量避免让一个普通构造函数与一个参数带initializer\_list的构造函数发生冲突

C++11中的变量初始化

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 C语言变量的初始化

相关【自学C++】C++变量初始化

相关【C++11】统一的列表初始化（ {}初始化）

相关 C++11 列表初始化

相关 C++11中的变量初始化

相关 C++类中成员变量初始化

相关 C++类中成员变量的初始化总结

相关【c++】c++11初始化

相关 C语言中的未初始化变量的值

相关 C++变量初始化问题