通过引用同一向量的元素插入向量

Question

我想知道是否有更有经验的人可以澄清这是否是对向量执行的错误操作：

std::vector<int> v{1, 2, 3, 4, 5};
v.insert(v.begin() + 1, v[0]);

我问的原因是因为要插入的元素是对向量中第 0 个元素的引用。如果插入强制向量调整大小（因为它的容量已满），那么对 v[0] 的引用将无效，并且代码可能会插入不正确的值。下面是一些可能演示的伪代码：

template <typename T>
void vector_insert_method(Iterator pos, const T& value) {
    if capacity full:
        reallocate array and copy over element
        // if value was reference to elem in this vector,
        // that reference might be invalidated


    insert element

    ++size
}

这个问题在并发系统上可能更现实。

一个类似且相关的问题是，如果您尝试插入位于您尝试插入的位置之后的元素，会发生什么情况。例如，执行v.insert(v.begin(), v[2]) 之类的操作，因为标准指出对插入点之后的元素的引用无效。这能保证有效吗？

Answer 1

原来的问题问...

[..] 这是否是对向量执行的错误操作：

v.insert(v.begin(), v[0]);
//              ^^^ no + 1 here!

可能是的，它可能是未定义的行为。引用N3337 ("almost C++11" AFAIK):

[..] 如果没有发生重新分配，插入点之前的所有迭代器和引用仍然有效。 [..]

§23.3.6.5/1

虽然这不是阅读标准时所习惯的清晰措辞，但我将其解释为：迭代器和对插入点及其之后的引用无效。

因此，对v[0] 的引用因对insert 的调用(*) 而无效。即使没有发生重新分配，insert 必须将所有元素移动到更高的索引（因此 v[0] 被重新定位到 v[1]）。

假设元素类型不是容易被破坏，那么无论是如何重新定位（通过移动或复制），在v[1] 之后从v[0] 分配/构造，v[0] 的析构函数需要被调用（并且它的生命周期结束）在一个新对象（您要插入的对象）可以放置在内存位置的v[0]。因此，在这里您的引用变成了一个悬空引用，当它被直接用于构造新的v[0] 时，这会导致未定义的行为。不，据我所知，这个问题可以通过让std::vector::insert() 不构造新对象而是分配新对象到“旧”对象来规避.我不确定std::vector 是否需要这样做，尽管它的元素类型必须是CopyInsertable 暗示这可能是这种情况。

更新： I've played around with the code 在另一个答案中提供，添加了一些打印调试。这表明不是我所期望的（破坏一个元素然后访问它）但仍然表明标准库实现（这里由 ideone 使用）确实不是 符合标准：它使对插入点之前的元素的引用无效即使容量足够大。这样它就绕过了上述问题（但违反了标准......所以）。

(*)：人们可能会争论何时会发生失效。该问题的最佳答案是 IMO 引用在调用 insert 函数之前有效，并且在从该函数返回后无效（肯定）。失效的确切点未指定。

---

编辑后的问题提出了同样的问题，但做了一个极其重要的修改：

v.insert(v.begin() + 1, v[0]);
//                ^^^^^

现在情况完全不同了。对v[0] 的引用不一定会因对insert 的调用而失效，因为插入点在“后面”v[0]。唯一可能出现的问题是 std::vector 是否必须重新分配其内部缓冲区，但在这种情况下，以下操作序列应保证正确的行为：

1. 分配更大容量的新内存
2. 在新分配的内存区域的正确索引处构造新元素。
3. 将元素从旧（太小）内存复制/移动到新分配的内存区域。
4. 释放旧内存。

Answer 2

好吧，经过大量的环顾，似乎标准库有义务完成这项工作。这个想法是，由于标准没有明确说明这不应该起作用，所以它必须起作用。

Andrew Koenig 在这里写了一点，并提出了一个解决方案，即分配新内存，移动元素，然后释放旧内存。

还有其他讨论here和here (#526)。

对于第二种情况，标准库（MacOS 上的 clang）似乎也解释了您尝试在向量中插入对位于您尝试插入的点之后的元素的引用的情况.为了测试这一点，我为 int 编写了一个名为 Integer 的包装类，它的行为与 int 完全相同，只是析构函数将其内部值设置为 -5。因此，如果 std::vector 插入不考虑这种情况，我们应该看到插入了 -5 而不是实际值。

#include <vector>
#include <iostream>


using std::cout;    using std::endl;
using std::ostream; using std::vector;


class Integer {

public:
    Integer() {
        x = -1;     // default value
    }

    ~Integer() {
        x = -5;     // destructed value. Not 0 so we can clearly see it
    }

    Integer(int r) {
        x = r;
    }

    Integer(const Integer& other) {
        x = other.x;
    }

    Integer operator=(const Integer& other) {
        x = other.x;
        return *this;
    }

    operator int() const{
        return x;
    }

    friend ostream& operator<<(ostream& os, const Integer& thing) {
        os << thing.x;
        return os;
    }

private:
    int x;
};


ostream& operator<<(ostream& os, const vector<Integer> &v) {
    std::copy(v.begin(), v.end(), std::ostream_iterator<Integer>(os, ", "));
    return os;
}

int main() {
    std::vector<Integer> ret {18, 7, 4, 24,11};
    cout << "Before: " << ret << endl;
    ret.insert(ret.begin(), ret[1]);
    cout << "After: " <<  ret << endl;
    return 0;
}

这给了我们正确的输出：

Before: 18, 7, 4, 24, 11, 
After: 7, 18, 7, 4, 24, 11,