我有一个自定义的 Vec 类，复制了 std：：vector 的功能，但我无法实现一个 erase 函数，该函数采用与标准库实现相同的参数(并优雅地处理它们)。具体来说，在 C++11 中，vector：：erase 具有签名iterator erase (const_iterator position);，其中返回的迭代器指向元素删除后元素的新位置。我唯一的解决方案是传递一个非常量迭代器，使用第二个迭代器将给定迭代器后的所有元素复制回一个位置，并使用第三个迭代器来存储原始指针位置。这需要三个非常量迭代器。
template <class T> typename Vec<T>::iterator Vec<T>::erase(iterator it)
{
iterator copy_iterator = it; // used to shift elements one position to the left past the deleted element.
iterator return_iterator = it; // holds original it position, per std implementation
while (it != (this -> end() - 1)) { // copies elements one position left
*copy_iterator++ = *++it;
}
alloc.destroy(it); // destroy last element in vector
avail = it; // shortens the vector by 1
return return_iterator;
}
这里可用的是迭代器，它指向一个经过向量末端的迭代器，即iterator end() { return avail; }.如果它必须移动每个元素，我不明白任何这样的函数如何const_iterator，而且我真的不喜欢有三个迭代器。有没有更好的解决方案？
附加标准问题：
直到 C++98，vector：：erase 都采用了一个迭代器参数。我很好奇为什么这个标准被改变了。在 C++11 中，erase 函数包括从 const_iterator 到迭代器的直接转换，而没有进一步解释为什么现在是 const。
template <class T> typename vector<T>::iterator erase(const_iterator __position) {
difference_type __ps = __position - cbegin();
pointer __p = this->__begin_ + __ps;
iterator __r = __make_iter(__p);
this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p));
return __r;
}
下面是 Vec 类的部分实现：
template <class T> class Vec {
public:
// typedefs
Vec() { create(); }
explicit Vec(std::size_t n, const T& val = T()) { create(n, val); }
Vec(const Vec& v) { create(v.begin(), v.end()); } // copy constructor
Vec& operator=(const Vec&);
~Vec() { uncreate(); } // destructor
T& operator[](size_type i) { return data[i]; }
const T& operator[](size_type i) const { return data[i]; }
void push_back(const T& val) {
if (avail == limit)
grow();
unchecked_append(val);
}
size_type size() const { return avail - data; }
iterator begin() { return data; }
const_iterator begin() const { return data; }
iterator end() { return avail; }
const_iterator end() const { return avail; }
iterator erase(iterator);
private:
iterator data;
iterator avail;
iterator limit;
allocator<T> alloc;
void create();
void create(size_type, const T&);
void create(const_iterator, const_iterator); // calls alloc.allocate, then copies without default initialization
void uncreate(); // calls alloc.destroy on everything, then deallocates
void grow(); // allocates twice the memory
void unchecked_append(const T&);
};
只需将您的const_iterator转换为函数中的iterator即可。现在，通常情况下，这将是一个禁忌。但是由于我们知道Vec不是 const (因为erase是一个非 const 函数)，这是安全的，除非用户传递不属于Vec的迭代器(无论如何都不安全)。
那么，如何从const_iterator获得非常量iterator呢？您可以在const_iterator类中实现一个私有成员来执行此操作，并使Vec类成为朋友。但是由于我们正在处理随机访问迭代器，因此没有必要，因为我们只能使用迭代器算法。
// given a const_iterator cit
iterator it = begin() + (cit - begin());
我不知道对此的最佳答案，但从我所看到的情况来看，您可以使用指针算术重新派生一个指向擦除位置的非常量指针/迭代器，或者做一个法律const_cast安全知道你的数组实际上是真实的(non-const创建)，因为擦除是一个非常量函数，不能在常量对象上调用。
template <class T> typename Vec<T>::iterator Vec<T>::erase(const_iterator it)
{
iterator non_const_it = this->begin() + std::distance(this->cbegin(), it);
iterator copy_iterator = non_const_it;
// etc...
return non_const_it;
}