为什么在 C++ 中使用 = 来初始化原始类型？

Question

在我工作的地方，人们大多认为对象最好使用 C++ 风格的构造（带括号）来初始化，而原始类型应该使用 = 运算符来初始化：

std::string strFoo( "Foo" );
int nBar = 5;

不过，似乎没有人能够解释为什么他们更喜欢这种方式。 我可以看到 std::string strFoo = "Foo"; 效率很低，因为它会涉及额外的副本，但是完全消除 = 运算符有什么问题并且到处使用括号？

这是一个共同的约定吗？ 其背后的想法是什么？

Answer 1

使用 = 运算符或使用构造函数调用初始化变量在语义上是相同的，这只是风格问题。 我更喜欢 = 运算符，因为它读起来更自然。

使用 = 运算符通常不会生成额外的副本 - 它只是调用普通的构造函数。 但请注意，对于非基本类型，这仅适用于与声明同时发生的初始化。 比较：

std::string strFooA("Foo");  // Calls std::string(const char*) constructor
std::string strFoo = "Foo";  // Calls std::string(const char*) constructor
                             // This is a valid (and standard) compiler optimization.

std::string strFoo;  // Calls std::string() default constructor
strFoo = "Foo";      // Calls std::string::operator = (const char*)

当您有重要的默认构造函数时，后一种构造可能会稍微低效一些。

C++ 标准，第 8.5 节，第 14 段状态：

否则（即，对于其余的复制初始化情况），将创建一个临时文件。 枚举可以从源类型转换为目标类型或其派生类的用户定义的转换序列（13.3.1.4），并通过重载决策选择最佳的转换序列（13.3）。 调用如此选择的用户定义转换，将初始值设定项表达式转换为临时表达式，其类型是调用用户定义转换函数返回的类型，并带有 cv 限定符
目的地类型。 如果转换无法完成或不明确，则初始化格式错误。 然后直接初始化正在初始化的对象
根据上述规则从临时对象中删除。⁸⁷) 在某些情况下，允许实现通过直接初始化对象来消除临时对象； 参见12.2。

第 12.2 节的一部分规定：

即使避免创建临时对象，也必须遵守所有语义限制，就像创建临时对象一样。 [例子：
即使不调用复制构造函数，也应满足所有语义限制，例如可访问性（11）。 ]

Answer 2

我只是觉得需要再写一篇愚蠢的闲聊帖子。

string str1 = "foo";

称为复制初始化，因为编译器在不删除任何临时变量的情况下所做的事情是：

string str1(string("foo")); 

除了检查所使用的转换构造函数是否是隐式的之外。 事实上，所有隐式转换都是由标准在复制初始化方面定义的。 据说从类型 U 到类型 T 的隐式转换是有效的，如果

T t = u; // u of type U

是有效的。

相比之下，

string str1("foo");

完全按照编写的内容进行操作，称为直接初始化。 它也适用于显式构造函数。

顺便说一句，您可以使用 -fno-elide-constructors 禁用临时变量的消除：

-fno-elide-constructors
    The C++ standard allows an implementation to omit creating a temporary which 
    is only used to initialize another object of the same type. Specifying this 
    option disables that optimization, and forces G++ to call the copy constructor 
    in all cases.

---

之间实际上没有区别

T a = u;

和

T a(u);

标准表示，如果 T 和 u 的类型是原始类型，则 。 所以您可以使用这两种形式。 我认为正是它的风格让人们使用第一种形式而不是第二种形式。

---

有些人可能在某些情况下使用第一个，因为他们想消除声明的歧义：

T u(v(a));

可能会将某人视为使用类型 v< 的临时变量初始化的变量 u 的定义。 /code> 为其构造函数获取一个名为 a 的参数。 但事实上，编译器对此所做的事情是这样的：

T u(v a);

它创建一个函数声明，该函数声明采用 v 类型的参数，并带有一个名为 a 的参数。 因此，人们确实可以

T u = v(a);

消除歧义，即使他们

T u((v(a)));

也可以这样做，因为函数参数周围永远没有括号，编译器也会将其读取为变量定义而不是函数声明:)

Answer 3

除非您已经证明它对性能很重要，否则我不会担心在示例中使用赋值运算符进行额外的复制（std::string foo = "Foo";）。 一旦您查看优化的代码，如果该副本存在，我会感到非常惊讶，我相信它实际上会调用适当的参数化构造函数。

在回答你的问题时，是的，我想说这是一个非常常见的惯例。 传统上，人们使用赋值来初始化内置类型，并且没有令人信服的理由来改变传统。 鉴于它对最终代码的影响很小，可读性和习惯是这种约定的完全正当的理由。

Answer 4

您可能会发现诸如此类的代码

std::string strFoo = "Foo";

将避免进行额外的复制，并编译为与带括号的代码相同的代码（调用单参数构造函数）。

另一方面，在某些情况下，必须使用括号，例如构造函数成员初始化列表。

我认为使用=或括号来构造局部变量很大程度上是个人选择的问题。

Answer 5

好吧，谁知道他们怎么想，但我也更喜欢原始类型的=，主要是因为它们不是对象，而且因为这是初始化它们的“通常”方式。

Answer 6

但是，为了让您更加困惑，您使用对象语法在初始化列表中初始化基元。

foo::foo()   
  ,anInt(0)   
  ,aFloat(0.0)   
{   
}   

Answer 7

这是风格问题。 即使“std::string = "Foo"; 的说法也是低效的，因为它会涉及额外的副本”也是不正确的。 这个“额外的副本”被编译器删除。

Answer 8

我相信这更多是一种习惯，很少有对象可以使用 = 初始化，字符串就是其中之一。 这也是执行您所说的“到处使用括号（该语言允许您使用它）”的一种方式

Answer 9

可以提出的一个论点是：

std::string foo("bar");

即使参数计数发生变化，它也会保持不变，即：

std::string foo("bar", 5);

不适用于“=”符号。

另一件事是，对于许多对象来说，“=”感觉不自然，例如，假设您有一个 Array 类，其中参数给出长度：

Array arr = 5;

感觉不太好，因为我们不构造一个值为 5 的数组，而是构造长度为 5 的数组：

Array arr(5);

感觉更自然，因为您正在使用给定参数构造一个对象，而不仅仅是复制一个值。