如何为向量实现std :: erase？

Question

I have a custom Vec class, duplicating the functionality of std::vector, but I am unable to implement an erase function which takes the same parameters as the standard library implementation (and handles them elegantly). Specifically, in C++11, vector::erase has the signature iterator erase (const_iterator position); , where the returned iterator points to the new position of the element after the element deleted. My only solution is to pass a non-const iterator, copy all the elements after the given iterator back one position with a second iterator, and use a third iterator to store the original pointer position. This requires three non-const iterator.

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;
}

Here avail is the iterator which points one past the end of the vector, ie iterator end() { return avail; } iterator end() { return avail; } . I don't see how any such function could take a const_iterator if it has to shift every element left by one, and I really don't like having three iterators. Is there a better solution?

Additional Standards Question:

Up until C++98 , vector::erase took an iterator parameter. I am curious why this standard was changed. In C++11, the erase functions includes what looks a direct conversion from const_iterator to iterator without any further explanation for why it is now 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;
}

Here is a partial implementation of the Vec class:

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&);
};

Answer 1

Simply convert your const_iterator to an iterator within the function. Now, normally, this would be a no-no. But since we know that the Vec is not const (because erase is a non-const function), this is safe, unless the user passes an iterator that doesn't belong to the Vec (which is not safe regardless).

So, how to get a non-const iterator from a const_iterator ? You could implement a private member in your const_iterator class to do this and make the Vec class a friend. But since we're dealing with random access iterators, that is not necessary since we can just use iterator arithmetic.

// given a const_iterator cit
iterator it = begin() + (cit - begin());

Answer 2

I don't know the best answer to this but from what I can see you could re-derive a non-const pointer/iterator to the erase position using pointer arithmetic or do a legal const_cast secure in the knowledge that your array is actually real (was created non-const ) because erase is a non-const function and could not be called on a const object.

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;
}