将临时对象移动到向量中

Question

#include <iostream>
#include <utility>
#include <vector>

int i = 0;
struct A
{
    A() : j( ++i )
    {
        std::cout<<"constructor "<<j<<std::endl;
    }
    A( const A & c) : j(c.j)
    {
        std::cout<<"copy "<<j<<std::endl;
    }
    A( const A && c) : j(c.j)
    {
        std::cout<<"move "<<j<<std::endl;
    }
    ~A()
    {
        std::cout<<"destructor "<<j<<std::endl;
    }

    int j;
};

typedef std::vector< A > vec;

void foo( vec & v )
{
    v.push_back( std::move( A() ) );
}

int main()
{
    vec v;

    foo( v );
    foo( v );
}

上面的示例产生下一个输出：

constructor 1
move 1
destructor 1
constructor 2
move 2
move 1
destructor 1
destructor 2
destructor 1
destructor 2

问题：

1. 为什么执行第一个析构函数（但不为第二个对象执行它）？
2. 为什么第二个对象的移动在第一个对象的移动之前执行？
3. 为什么最后每个对象执行两个析构函数？

PS我刚刚检查过，对象确实按预期放置（第一个位于向量中的位置 0，第二个位于向量中的位置 1）

PPS 如果重要的话，我正在使用 gcc 4.3，并且我像这样编译程序：

g++ n1.cpp -Wall -Wextra -pedantic -ansi -std=c++0x -O3

Answer 1

我稍微重新编码了您的示例：

#include <iostream>
#include <utility>
#include <vector>

int i = 0;
struct A
{
    A() : j( ++i )
    {
        std::cout<<"constructor "<<j<<std::endl;
    }
    A( const A & c) : j(c.j)
    {
        std::cout<<"copy "<<j<<std::endl;
    }
    A( A && c) : j(c.j)
    {
        std::cout<<"move "<<j<<std::endl;
    }
    ~A()
    {
        std::cout<<"destructor "<<j<<std::endl;
    }

    int j;
};

typedef std::vector< A > vec;

void foo( vec & v )
{
    v.push_back( A() );
}

int main()
{
    vec v;
    std::cout << "A\n";
    foo( v );
    std::cout << "B\n";
    foo( v );
    std::cout << "C\n";
}

1. 我从移动构造函数中删除了 const 。
2. 我已经从 push_back 中删除了 std::move （它是多余的）。
3. 我在对 foo 的调用之间插入了标记。

对我来说，这打印出来的结果与您的代码类似：

A
constructor 1
move 1
destructor 1
B
constructor 2
move 2
copy 1
destructor 1
destructor 2   // 1
C
destructor 2
destructor 1

1. 为什么第一个析构函数被执行（但它没有被执行）
   第二个对象）？

第二个析构函数在标记为 // 1 的行处对第二个对象执行。这是在第二次调用 push_back 结束时销毁临时 A()。

1. 为什么第二个对象的移动要在第一个对象的移动之前执行
   对象？

注意：对我来说，第一个对象是复制的，而不是移动的，更多信息如下。

答：异常安全。

解释：在此 push_back 期间，向量发现它有一个已满的缓冲区（一个），并且需要创建一个可容纳两个的新缓冲区。它创建新的缓冲区。然后将第二个对象移动到该缓冲区中（在其末尾）。如果该构造引发异常，则原始缓冲区仍然完好无损，并且向量保持不变。否则，元素将从第一个缓冲区移动或复制到第二个缓冲区（从而第二个移动/复制第一个元素）。

如果 A 有一个 noexcept 移动构造函数，则将使用 move 将其从旧缓冲区移动到新缓冲区。但是，如果移动构造函数不是 noexcept，则将使用 copy。这又是为了异常安全。如果从旧缓冲区到新缓冲区的移动可能失败，则必须保持旧缓冲区完好无损，以便向量可以恢复到其原始状态。

如果我将 noexcept 添加到您的移动构造函数中：

A( A && c) noexcept : j(c.j)
{
    std::cout<<"move "<<j<<std::endl;
}

那么我的输出是：

A
constructor 1
move 1
destructor 1
B
constructor 2
move 2
move 1
destructor 1  // 2
destructor 2
C
destructor 2
destructor 1

注意标记为 // 2 的行是旧缓冲区中第一个元素的销毁，在它具有已移动构建到新缓冲区中。

1. 为什么每个对象最后都会执行两个析构函数？

这标志着 vector 的破坏，从而标记 vector 的每个元素的破坏。

Answer 2

明智地使用 reserve 可以解决一半的问题：http://ideone.com/5Lya6< /a> 通过减少意外移动的数量（您没有明确请求）。

另外，不要忘记，temp 的析构函数在移动到向量后仍然会触发。这就是为什么即使在移动分配/构造之后，您也必须确保温度保持在正常、可破坏的状态。

#include <iostream>
#include <utility>
#include <vector>

int i = 0;
struct A
{
    A() : j( ++i )
    {
        std::cout<<"constructor "<<j<<std::endl;
    }
    A( const A & c) : j(c.j)
    {
        std::cout<<"copy "<<j<<std::endl;
    }
    A( const A && c) : j(c.j)
    {
        std::cout<<"move "<<j<<std::endl;
    }
    ~A()
    {
        std::cout<<"destructor "<<j<<std::endl;
    }

    int j;
};

typedef std::vector< A > vec;

void foo( vec & v )
{
    v.push_back( std::move( A() ) );
}

int main()
{
    vec v;
    v.reserve(2);

    foo( v );
    foo( v );
}

Answer 3

向量在调用 push_back 期间增加其容量并移动内部元素。

Answer 4

移动构造函数不会“销毁”移动的对象。

#include <iostream>

struct Foo { 
  int i;
  bool active;

  Foo(int i): i(i), active(true) {}
  Foo(Foo&& rhs): i(rhs.i), active(rhs.active) { rhs.active = false; }
  Foo(Foo const& rhs): i(rhs.i), active(rhs.active) {}
  ~Foo() { std::cout << i << (active ? " active": " inactive") << "\n"; }
};


int main() {
  Foo foo;
  Bar bar(std::move(foo));
}

输出给出：

1 active
1 inactive