复制初始化和直接初始化有区别吗？

Question

假设我有这个函数：

void my_test()
{
    A a1 = A_factory_func();
    A a2(A_factory_func());

    double b1 = 0.5;
    double b2(0.5);

    A c1;
    A c2 = A();
    A c3(A());
}

在每个分组中，这些语句是否相同？ 或者在某些初始化中是否有额外的（可能是可优化的）副本？

我见过人们说这两件事。 请引用文字作为证据。 还请添加其他案例。

Answer 1

C++17 更新

在 C++17 中，A_factory_func() 的含义从创建临时对象 (C++<=14) 更改为仅指定此表达式所属的任何对象的初始化在 C++17 中初始化为（宽松地说）。 这些对象（称为“结果对象”）是由声明创建的变量（例如 a1）、初始化最终被丢弃时创建的人工对象，或者引用绑定需要对象（例如，在 A_factory_func(); 中，最后一种情况是人为创建的，称为“临时物化”，因为 A_factory_func() 没有变量或引用。否则需要一个对象存在）。

作为我们案例中的示例，在 a1 和 a2 的情况下，特殊规则规定，在此类声明中，纯右值初始值设定项的结果对象与 类型相同a1 是变量 a1，因此 A_factory_func() 直接初始化对象 a1。 任何中间函数式类型转换都不会产生任何效果，因为 A_factory_func(another-prvalue) 只是“传递”外部纯右值的结果对象，使其成为内部纯右值的结果对象。

---

A a1 = A_factory_func();
A a2(A_factory_func());

取决于 A_factory_func() 返回的类型。 我假设它返回一个 A - 那么它会做同样的事情 - 只不过当复制构造函数是显式的时，第一个将会失败。 阅读 8.6/14

double b1 = 0.5;
double b2(0.5);

这是做同样的事情，因为它是一个内置类型（这意味着这里不是类类型）。 阅读8.6/14。

A c1;
A c2 = A();
A c3(A());

这不是做同样的事情。 如果 A 是非 POD，则第一个默认初始化，并且不会对 POD 进行任何初始化（请阅读 8.6/9)。 第二个副本初始化：值初始化一个临时值，然后将该值复制到 c2 （阅读 5.2.3/2 和 8.6/ 14）。 这当然需要一个非显式的复制构造函数（阅读8.6/14和 12.3.1/3 和 13.3.1.3/1 ）。 第三个为函数 c3 创建函数声明，该函数返回 A 并接受一个指向返回 A 的函数的函数指针（读取 < a href="http://eel.is/c++draft/dcl.ambig.res" rel="noreferrer">8.2）。

---

深入研究初始化 直接初始化和复制初始化

虽然它们看起来相同并且应该执行相同的操作，但这两种形式在某些情况下却有显着不同。 初始化的两种形式是直接初始化和复制初始化：

T t(x);
T t = x;

我们可以将它们归因于每种形式：

• 直接初始化的行为类似于对重载函数的函数调用：在这种情况下，函数是 T< 的构造函数/code>（包括显式），参数为x。 重载解析将找到最佳匹配的构造函数，并在需要时执行所需的任何隐式转换。
• 复制初始化构造一个隐式转换序列：它尝试将x转换为T类型的对象。 （然后它可能会将该对象复制到要初始化的对象中，因此也需要复制构造函数 - 但这在下面并不重要）

如您所见，复制初始化在某种程度上是关于可能的隐式转换的直接初始化：虽然直接初始化具有所有可供调用的构造函数，并且此外可以执行匹配参数类型所需的任何隐式转换，但复制初始化只能设置一个隐式转换转换序列。

我努力尝试得到以下代码为每种表单输出不同的文本，没有通过显式构造函数使用“明显”。

#include <iostream>
struct B;
struct A { 
  operator B();
};

struct B { 
  B() { }
  B(A const&) { std::cout << "<direct> "; }
};

A::operator B() { std::cout << "<copy> "; return B(); }

int main() { 
  A a;
  B b1(a);  // 1)
  B b2 = a; // 2)
}
// output: <direct> <copy>

它是如何工作的，为什么会输出这个结果？

1. 直接初始化

   它首先对转换一无所知。 它只会尝试调用构造函数。 在这种情况下，以下构造函数可用并且完全匹配：

    B(A const&) 
     

   调用该构造函数不需要任何转换，更不用说用户定义的转换（请注意，这里也没有发生 const 限定转换）。 所以直接初始化就会调用它。

2. 复制初始化

   如上所述，当 a 没有类型 B 或从它派生时（这里显然是这种情况），复制初始化将构造一个转换序列。 因此它将寻找进行转换的方法，并会找到以下候选者

    B(A const&) 
      运算符 B(A&); 
     

   请注意我如何重写转换函数：参数类型反映了 this 指针的类型，在非常量成员函数中是非常量的。 现在，我们用 x 作为参数来调用这些候选者。 获胜者是转换函数：因为如果我们有两个候选函数都接受对同一类型的引用，那么 less const 版本会获胜（顺便说一句，这也是更喜欢非 const 的机制） -const 成员函数调用非常量对象）。

   请注意，如果我们将转换函数更改为 const 成员函数，则转换是不明确的（因为两者的参数类型均为 A const&）：Comeau 编译器会正确拒绝它，但 GCC 以非迂腐模式接受它。 不过，切换到 -pedantic 也会使其输出正确的歧义警告。

Answer 2

赋值与初始化不同。

以下两行都会进行初始化。 完成了单个构造函数调用：

A a1 = A_factory_func();  // calls copy constructor
A a1(A_factory_func());   // calls copy constructor

但它不等于：

A a1;                     // calls default constructor
a1 = A_factory_func();    // (assignment) calls operator =

我目前没有文本来证明这一点，但很容易进行实验：

#include <iostream>
using namespace std;

class A {
public:
    A() { 
        cout << "default constructor" << endl;
    }

    A(const A& x) { 
        cout << "copy constructor" << endl;
    }

    const A& operator = (const A& x) {
        cout << "operator =" << endl;
        return *this;
    }
};

int main() {
    A a;       // default constructor
    A b(a);    // copy constructor
    A c = a;   // copy constructor
    c = b;     // operator =
    return 0;
}

Answer 3

double b1 = 0.5; 是构造函数的隐式调用。

double b2(0.5); 是显式调用。

查看以下代码以了解差异：

#include <iostream>
class sss { 
public: 
  explicit sss( int ) 
  { 
    std::cout << "int" << std::endl;
  };
  sss( double ) 
  {
    std::cout << "double" << std::endl;
  };
};

int main() 
{ 
  sss ddd( 7 ); // calls int constructor 
  sss xxx = 7;  // calls double constructor 
  return 0;
}

如果您的类没有显式构造函数，则显式调用和隐式调用是相同的。

Answer 4

当你初始化一个对象时，你可以看到它在显式和隐式构造函数类型中的区别：

类：

class A
{
    A(int) { }      // converting constructor
    A(int, int) { } // converting constructor (C++11)
};

class B
{
    explicit B(int) { }
    explicit B(int, int) { }
};

并且在 main function :

int main()
{
    A a1 = 1;      // OK: copy-initialization selects A::A(int)
    A a2(2);       // OK: direct-initialization selects A::A(int)
    A a3 {4, 5};   // OK: direct-list-initialization selects A::A(int, int)
    A a4 = {4, 5}; // OK: copy-list-initialization selects A::A(int, int)
    A a5 = (A)1;   // OK: explicit cast performs static_cast

//  B b1 = 1;      // error: copy-initialization does not consider B::B(int)
    B b2(2);       // OK: direct-initialization selects B::B(int)
    B b3 {4, 5};   // OK: direct-list-initialization selects B::B(int, int)
//  B b4 = {4, 5}; // error: copy-list-initialization does not consider B::B(int,int)
    B b5 = (B)1;   // OK: explicit cast performs static_cast
}

默认情况下，构造函数是隐式，因此您有两种方法来初始化它：

A a1 = 1;        // this is copy initialization
A a2(2);         // this is direct initialization

以及将结构定义为 显式 只是你有一种直接的方式：

B b2(2);        // this is direct initialization
B b5 = (B)1;    // not problem if you either use of assign to initialize and cast it as static_cast

Answer 5

值得注意的是：

[12.2/1] 类类型的临时对象是在各种上下文中创建的：...以及在某些初始化 (8.5) 中。

即，用于复制初始化。

[12.8/15] 当满足某些条件时，允许实现省略类对象的复制构造...

换句话说，一个好的编译器不会当可以避免时，创建一个用于复制初始化的副本； 相反，它只会直接调用构造函数——即，就像直接初始化一样。

换句话说，在大多数情况下，复制初始化就像直接初始化一样编写了可理解的代码的地方。 由于直接初始化可能会导致任意（因此可能未知）转换，因此我更喜欢尽可能使用复制初始化。 （好处是它实际上看起来像初始化。）

技术精湛：
[12.2/1 续上] 即使避免创建临时对象 (12.8)，也必须遵守所有语义限制，就像创建临时对象一样。

很高兴我没有写C++ 编译器。

Answer 6

第一个分组：取决于 A_factory_func 返回的内容。 第一行是复制初始化的示例，第二行是直接初始化。 如果 A_factory_func 返回一个 A 对象，那么它们是等价的，它们都调用 A 的复制构造函数，否则第一个版本创建类型的右值A 来自 A_factory_func 返回类型的可用转换运算符或适当的 A 构造函数，然后调用复制构造函数来构造 a1 从这个临时的。 第二个版本尝试找到一个合适的构造函数，该构造函数接受 A_factory_func 返回的任何内容，或者接受返回值可以隐式转换为的内容。

第二组：完全相同的逻辑，除了内置类型没有任何外来构造函数，因此实际上它们是相同的。

第三组：c1 默认初始化，c2 从临时初始化的值复制初始化。 如果用户提供的默认构造函数（如果有）没有显式初始化它们，则具有 pod 类型的 c1 的任何成员（或成员的成员等）可能不会被初始化。 对于c2，这取决于是否存在用户提供的复制构造函数以及是否适当地初始化这些成员，但临时的成员都将被初始化（如果没有以其他方式显式初始化，则初始化为零）。 正如 litb 所发现的，c3 是一个陷阱。 它实际上是一个函数声明。

Answer 7

关于这部分的回答：

A c2 = A(); A c3(A());

由于大多数答案都是 c++11 之前的，所以我添加了 c++11 对此的说明：

简单类型说明符 (7.1.6.2) 或类型名称说明符 (14.6)
后跟一个带括号的表达式列表构造一个值
给定表达式列表的指定类型。 如果表达式列表是
单个表达式，类型转换表达式是等效的（在
定义性，如果定义了意义）到相应的强制转换
表达式（5.4）。 如果指定的类型是类类型，则该类
类型应完整。 如果表达式列表指定多个
单值，类型应是具有适当声明的类
构造函数 (8.5, 12.1)，表达式 T(x1, x2, ...) 为
对于某些情况，相当于声明 T t(x1, x2, ...);
发明了临时变量 t，其结果是 t 的值：
右值。

因此，无论是否优化，根据标准它们都是等效的。
请注意，这与其他答案提到的一致。 为了正确起见，只是引用标准的内容。

Answer 8

这是来自 Bjarne Stroustrup 的 C++ 编程语言：

带有 = 的初始化被视为复制初始化。 原则上，初始化器的副本（我们从中复制的对象）被放置到已初始化的对象中。 然而，这样的副本可以被优化掉（省略），并且如果初始值设定项是右值，则可以使用移动操作（基于移动语义）。 省略 = 会使初始化变得明确。 显式初始化称为“直接初始化”。

Answer 9

很多情况都取决于对象的实现，因此很难给您具体的答案。

考虑这种情况

A a = 5;
A a(5);

在这种情况下，假设有一个正确的赋值运算符 & 初始化接受单个整数参数的构造函数，我如何实现所述方法会影响每行的行为。 然而，通常的做法是其中一个在实现中调用另一个来消除重复的代码（尽管在如此简单的情况下没有真正的目的。）

编辑：正如其他响应中提到的，第一行将实际上调用了复制构造函数。 将与赋值运算符相关的注释视为与独立赋值相关的行为。

也就是说，编译器如何优化代码将产生其自身的影响。 如果我有调用“=”运算符的初始化构造函数 - 如果编译器没有进行优化，那么顶行将执行 2 次跳转，而不是底行中的 1 次。

现在，对于最常见的情况，您的编译器将通过这些情况进行优化并消除此类低效率。 因此，实际上，您描述的所有不同情况都会产生相同的结果。 如果您想准确了解正在执行的操作，可以查看编译器的目标代码或汇编输出。