erase()函数源码

erase()函数是C++ STL中的一个函数，用于删除容器中的元素。下面是它的源码实现：

iterator erase(const_iterator position)
{
    difference_type offset = position - cbegin();
    if (offset < 0 || offset >= static_cast<difference_type>(size()))
        throw std::out_of_range("vector::erase");

    pointer p = data() + offset;
    std::move(p + 1, end(), p);
    pop_back();

    return begin() + offset;
}

该函数接收一个迭代器参数position，表示要删除的元素的位置。该函数首先计算出该位置与开头迭代器之间的距离offset，然后检查offset是否为负数或超出容器大小，若是则抛出std::out_of_range异常。

接下来，该函数通过指针p获取要删除的元素的地址，并将p之后的元素移动到p的位置上，然后通过pop_back()函数删除最后一个元素。最后，该函数返回一个迭代器，指向已删除元素的下一个元素。

需要注意的是，该函数只能用于可变容器，如std::vector、std::deque等，而不能用于不可变容器，如std::array、std::string等。

相关问题

vectorv erase

在C++中，vector的erase函数用于从vector中删除一个或多个元素。它有两种重载形式。

首先是erase函数的原型：

iterator erase(iterator position);

这个函数用于删除指定位置的元素，并返回被删除元素的下一个元素的迭代器。为了保证迭代器的有效性，通常需要将返回的迭代器重新赋值给原来的迭代器变量。

另外一种形式是：

iterator erase(iterator first, iterator last);

这个函数用于删除从[first, last)范围内的所有元素，并返回被删除元素的下一个元素的迭代器。

需要注意的是，在使用vector的erase函数时需要注意迭代器是否会失效。因为删除元素会导致容器的元素重新排列，可能会使之前的迭代器失效。所以在使用erase函数时，要确保迭代器的有效性。

你可以参考中的原文和中的链接了解更多关于vector中erase函数的用法和注意事项。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
- *1* [vector与map的erase()函数详细解析](https://download.csdn.net/download/weixin_38562329/14872771)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"]
- *2* [c++ Vector之erase（导致迭代器失效）vector.erase源码解析](https://blog.csdn.net/me1171115772/article/details/112003127)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"]
- *3* [vector中erase删除元素用法及注意事项](https://blog.csdn.net/u013171226/article/details/118762113)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"]
[ .reference_list ]

c++vector源码

C++中的vector是一个动态数组，它的源码实现在标准头文件<vector>中。下面是vector的一些关键实现细节：

// vector的定义
template <typename _Tp, typename _Alloc = std::allocator<_Tp>>
class vector {
public:
    // 构造函数
    vector() noexcept(noexcept(_Alloc())) : vector(_Alloc()) {}
    explicit vector(const _Alloc& __a) noexcept;
    explicit vector(size_type __n);
    vector(size_type __n, const value_type& __value,
           const _Alloc& __a = _Alloc());
    template <typename _InputIterator>
    vector(_InputIterator __first, _InputIterator __last,
           const _Alloc& __a = _Alloc());
    vector(const vector& __x);
    vector(vector&& __x) noexcept;
    vector(initializer_list<value_type> __l, const _Alloc& __a = _Alloc());
    // 析构函数
    ~vector();
    // 元素访问
    reference operator[](size_type __n) { return *(this->_M_impl._M_start + __n); }
    const_reference operator[](size_type __n) const { return *(this->_M_impl._M_start + __n); }
    reference at(size_type __n);
    const_reference at(size_type __n) const;
    reference front() { return *begin(); }
    const_reference front() const { return *begin(); }
    reference back() { return *(end() - 1); }
    const_reference back() const { return *(end() - 1); }
    pointer data() noexcept { return pointer_traits<pointer>::pointer_to(this->_M_impl._M_start); }
    const_pointer data() const noexcept { return pointer_traits<const_pointer>::pointer_to(this->_M_impl._M_start); }
    // 迭代器
    iterator begin() noexcept { return iterator(this->_M_impl._M_start); }
    const_iterator begin() const noexcept { return const_iterator(this->_M_impl._M_start); }
    iterator end() noexcept { return iterator(this->_M_impl._M_finish); }
    const_iterator end() const noexcept { return const_iterator(this->_M_impl._M_finish); }
    reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
    const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
    reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
    const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
    const_iterator cbegin() const noexcept { return const_iterator(this->_M_impl._M_start); }
    const_iterator cend() const noexcept { return const_iterator(this->_M_impl._M_finish); }
    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(cend()); }
    const_reverse_iterator crend() const noexcept { return const_reverse_iterator(cbegin()); }
    // 容量
    bool empty() const noexcept { return begin() == end(); }
    size_type size() const noexcept { return static_cast<size_type>(end() - begin()); }
    size_type max_size() const noexcept;
    void reserve(size_type __n);
    size_type capacity() const noexcept { return static_cast<size_type>(this->_M_impl._M_end_of_storage - this->_M_impl._M_start); }
    void shrink_to_fit() noexcept;
    // 修改器
    void clear() noexcept { _M_erase_at_end(this->_M_impl._M_start); }
    iterator insert(const_iterator __position, const value_type& __x);
    iterator insert(const_iterator __position, value_type&& __x);
    iterator insert(const_iterator __position, size_type __n, const value_type& __x);
    template <typename _InputIterator>
    iterator insert(const_iterator __position, _InputIterator __first, _InputIterator __last);
    iterator insert(const_iterator __position, initializer_list<value_type> __l) { return insert(__position, __l.begin(), __l.end()); }
    template <typename... _Args>
    iterator emplace(const_iterator __position, _Args&&... __args);
    iterator erase(const_iterator __position);
    iterator erase(const_iterator __first, const_iterator __last);
    void push_back(const value_type& __x);
    void push_back(value_type&& __x);
    template <typename... _Args>
    reference emplace_back(_Args&&... __args);
    void pop_back();
    void resize(size_type __new_size) { resize(__new_size, value_type()); }
    void resize(size_type __new_size, const value_type& __x);
    void swap(vector& __x) noexcept(_Alloc_traits::_S_nothrow_swap());
};