复制 vs std::move 用于整数

Question

• 在该示例中，默认副本和 std::move 有什么区别？
• move之后的对象，新旧对象之间是否存在依赖关系？

int main () {

    int a = 100;
    std::cout<<&a<<std::endl;

    auto a_copy = a;                 // deduced as int
    std::cout<<&a_copy<<std::endl;

    auto a_move = std::move(a);      // deduced as int
    std::cout<<&a_move<<std::endl;

};

输出：

0x7fffffffe094
0x7fffffffe098
0x7fffffffe09c

Answer 1

在 this 示例中，没有区别。我们最终会得到 3 个ints，值为 100。不过，不同类型肯定会有所不同。例如，让我们考虑类似vector<int>：

std::vector<int> a = {1, 2, 3, 4, 5}; // a has size 5
auto a_copy = a;                      // copy a. now we have two vectors of size 5
auto a_move = std::move(a);           // *move* a into a_move

最后一个变量a_move 拥有a 的内部指针。所以我们最终得到的是 a_move 是一个大小为 5 的向量，但 a 现在是空的。 move 比 copy 高效得多（想象一下，如果它是 1000 个字符串的向量 - a_copy 将涉及分配 1000 个字符串的缓冲区并复制 1000 个字符串，但 a_move 只分配几个指针)。

对于其他一些类型，其中一个可能是无效的：

std::unique_ptr<int> a{new int 42};
auto a_copy = a;            // error
auto a_move = std::move(a); // OK, now a_move owns 42, but a points to nothing

对于许多类型，但没有区别：

std::array<int, 100> a;
auto a_copy = a;            // copy 100 ints
auto a_move = std::move(a); // also copy 100 ints, no special move ctor

更一般地说：

T a;
auto a_copy = a;            // calls T(const T& ), the copy constructor
auto a_move = std::move(a); // calls T(T&& ), the move constructor

Answer 2

使用std::move 只是将左值更改为xvalue，因此它可以与移动构造函数和移动赋值运算符一起使用。这些对于内置类型不存在，因此在此示例中使用 move 没有区别。

Answer 3

在该示例中，默认副本和 std::move 有什么区别？

没有区别。复制某物满足移动的要求，在内置类型的情况下，移动被实现为复制。

移动对象后，新旧之间是否存在依赖关系

不，没有依赖关系。两个变量都是独立的。

Answer 4

为了扩展其他发帖人的答案，移动即复制范式也适用于由 POD 类型（或由 POD 类型组成的其他类型）组成的所有数据结构，如下例所示：

struct Foo
{
    int values[100];
    bool flagA;
    bool flagB;
};

struct Bar
{
    Foo foo1;
    Foo foo2;
};

int main()
{
    Foo f;
    Foo fCopy = std::move(f);
    Bar b;
    Bar bCopy = std::move(b);
    return 0;
}

在Foo 和Bar 的情况下，没有有意义的方式将数据从一个移动到另一个，因为两者最终都是 POD 类型的聚合 - 它们的数据都不是间接拥有的（指向或引用其他记忆）。因此，在这些情况下，移动是作为副本实现的，而原件（f、b）在 std::move() 行上的分配之后保持不变。

移动语义只能通过动态分配的内存或独特的资源来有意义地实现。