为什么我可以从常量向量中移动元素？

Question

下面的代码为什么编译？

#include <vector>
#include <iostream>

struct Foo {
  std::vector<int> bar = {1, 2, 3};
};

int main()
{
    Foo foo1;
    const Foo& foo2 = foo1;
    
    std::vector<int> target;
    
    std::move(foo2.bar.begin(), foo2.bar.end(), std::back_inserter(target));

    return 0;
}

std：：move的文档说

执行此操作后，“移动自”范围中的元素仍将包含适当类型的有效值，但不一定与移动前的值相同。

所以这实际上可以改变对象foo2，即使它声明为const。为什么这样做有效？

Answer 1

用例子来说明Andrey Semashev的答案，考虑一下：

#include <vector>

struct movable
{
    movable() = default;
    
    movable(const movable&) = delete;
    movable& operator=(const movable&) = delete;

    movable(movable&&) = default;
    movable& operator=(movable&&) = default;
};

struct copyable
{
    copyable() = default;
    
    copyable(const copyable&) = default;
    copyable& operator=(const copyable&) = default;

    copyable(copyable&&) = delete;
    copyable& operator=(copyable&&) = delete;
};

int main()
{
    // original example
    const std::vector<int> si;
    std::vector<int> ti;
    
    std::move(si.begin(), si.end(), std::back_inserter(ti)); // OK

    // example 2
    const std::vector<copyable> sc;
    std::vector<copyable> tc;
    
    std::move(sc.begin(), sc.end(), std::back_inserter(tc)); // OK

    // example 3
    const std::vector<movable> sv;
    std::vector<movable> tv;
    
    std::move(sv.begin(), sv.end(), std::back_inserter(tv)); // ERROR - tries to use copy ctor

    return 0;
}

即使copyable没有移动构造函数，示例2编译时没有错误，因为std:：move在这里选择了复制构造函数。

另一方面，示例3无法编译，因为可移动的的移动构造函数被否定（更好的词？）通过sv的一致性。你得到的错误是：

error: use of deleted function 'movable::movable(const movable&)'

这里有一个完整的例子。

Answer 2

所以这实际上可以改变对象foo2，即使它声明为const。为什么这样做有效？

如果可以的话，std:：move算法可以移动输入元素。

对于每个输入元素，它执行*dest=std:：move（*from），其中dest和from是输出和输入迭代器。由于from取消对常量对象的引用，std:：move（*from）创建一个右值引用const int

如果元素属于具有用户定义的复制和移动构造函数的类类型T，则重载解析必须选择复制构造函数（T（const T

底线是std:：move（带迭代器的算法）正在执行移动操作，该操作可能调用移动构造函数或赋值，也可能不调用移动构造函数或赋值。如果调用了move构造函数或赋值，并且该移动对源具有破坏性，那么算法将修改源元素。在其他情况下，它将只执行一个复制。