std::end std::cend

`std::end`和`std::cend`都是C++ STL库中的函数，用于返回指向容器结尾的迭代器。其中，`std::end`返回一个普通的迭代器，而`std::cend`返回一个常量迭代器，表示不允许修改容器中的元素。

使用示例：

#include <iostream>
#include <vector>
#include <algorithm>

int main() {
    std::vector<int> vec {1, 2, 3, 4, 5};

    // 使用普通迭代器遍历容器
    for (auto it = std::begin(vec); it != std::end(vec); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    // 使用常量迭代器遍历容器
    for (auto cit = std::cbegin(vec); cit != std::cend(vec); ++cit) {
        std::cout << *cit << " ";
    }
    std::cout << std::endl;

    return 0;
}

输出结果：

1 2 3 4 5 
1 2 3 4 5 

需要注意的是，`std::cend`只能用于常量容器，如果使用非常量容器，则需要使用`std::end`返回的普通迭代器。

相关问题

std::vector源码

`std::vector`是C++标准库中的一个容器，用于存储动态大小的数组。下面是`std::vector`的简化源码：

template<typename T, typename Allocator = std::allocator<T>>
class vector {
public:
    using value_type = T;
    using allocator_type = Allocator;
    using size_type = std::size_t;
    using difference_type = std::ptrdiff_t;
    using reference = value_type&;
    using const_reference = const value_type&;
    using pointer = typename std::allocator_traits<Allocator>::pointer;
    using const_pointer = typename std::allocator_traits<Allocator>::const_pointer;
    using iterator = pointer;
    using const_iterator = const_pointer;
    using reverse_iterator = std::reverse_iterator<iterator>;
    using const_reverse_iterator = std::reverse_iterator<const_iterator>;

    // 构造函数
    vector() noexcept;
    explicit vector(const Allocator& alloc) noexcept;
    explicit vector(size_type count, const T& value, const Allocator& alloc = Allocator());
    explicit vector(size_type count, const Allocator& alloc = Allocator());
    template<typename InputIt>
    vector(InputIt first, InputIt last, const Allocator& alloc = Allocator());
    vector(const vector& other);
    vector(const vector& other, const Allocator& alloc);
    vector(vector&& other) noexcept;
    vector(vector&& other, const Allocator& alloc) noexcept;
    vector(std::initializer_list<T> init, const Allocator& alloc = Allocator());

    // 析构函数
    ~vector();

    // 大小相关操作
    size_type size() const noexcept;
    size_type max_size() const noexcept;
    void resize(size_type count);
    void resize(size_type count, const value_type& value);
    size_type capacity() const noexcept;
    bool empty() const noexcept;
    void reserve(size_type new_cap);

    // 访问元素
    reference operator[](size_type pos);
    const_reference operator[](size_type pos) const;
    reference at(size_type pos);
    const_reference at(size_type pos) const;
    reference front();
    const_reference front() const;
    reference back();
    const_reference back() const;
    T* data() noexcept;

    // 迭代器操作
    iterator begin() noexcept;
    const_iterator begin() const noexcept;
    const_iterator cbegin() const noexcept;
    iterator end() noexcept;
    const_iterator end() const noexcept;
    const_iterator cend() const noexcept;
    reverse_iterator rbegin() noexcept;
    const_reverse_iterator rbegin() const noexcept;
    const_reverse_iterator crbegin() const noexcept;
    reverse_iterator rend() noexcept;
    const_reverse_iterator rend() const noexcept;
    const_reverse_iterator crend() const noexcept;

    // 修改容器
    void clear() noexcept;
    iterator insert(const_iterator pos, const T& value);
    iterator insert(const_iterator pos, T&& value);
    iterator insert(const_iterator pos, size_type count, const T& value);
    template<typename InputIt>
    iterator insert(const_iterator pos, InputIt first, InputIt last);
    iterator insert(const_iterator pos, std::initializer_list<T> init);
    iterator erase(const_iterator pos);
    iterator erase(const_iterator first, const_iterator last);
    void push_back(const T& value);
    void push_back(T&& value);
    template<typename... Args>
    reference emplace_back(Args&&... args);
    void pop_back();
    void swap(vector& other) noexcept;

    // 分配器相关操作
    allocator_type get_allocator() const noexcept;
};

`std::vector`的源码实现非常复杂，其中包含大量的模板和细节处理。但是，可以看到，它提供了许多方便的方法来访问和修改元素，以及管理容器的大小和内存分配。同时，它还支持迭代器，使得可以在容器中进行遍历和修改。

C++ std::map迭代器

C++ std::map迭代器是用来遍历map容器中的元素的工具。迭代器可以指向map容器中的每个键值对，允许访问键和值。在C++中，有三种常用的迭代器类型：基础迭代器、反向迭代器和常量迭代器。

基础迭代器是通过`begin()`和`end()`函数来获取的。`begin()`函数返回指向map容器中第一个元素的迭代器，而`end()`函数返回指向map容器中最后一个元素之后位置的迭代器。基础迭代器可以使用自增运算符`++`来遍历map容器中的键值对，并通过解引用(*)操作符来获得键和值。例如，使用`map<string, int>::iterator`类型定义迭代器，并通过循环遍历map容器中的键值对，可以实现对map容器的遍历。

反向迭代器是通过`rbegin()`和`rend()`函数来获取的。`rbegin()`函数返回指向map容器中最后一个元素的迭代器，而`rend()`函数返回指向map容器中第一个元素之前位置的迭代器。反向迭代器可以使用自减运算符`--`来遍历map容器中的键值对，并通过解引用(*)操作符来获得键和值。反向迭代器可以实现对map容器的反向遍历。

常量迭代器是通过`cbegin()`和`cend()`函数来获取的。常量迭代器与基础迭代器类似，但是不能修改map容器中的元素。常量迭代器可以用于在不改变map容器的情况下遍历元素。

综上所述，C++ std::map迭代器是用于遍历map容器中的键值对的工具。基础迭代器、反向迭代器和常量迭代器分别用于正向遍历、反向遍历和只读遍历map容器。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
- *1* [C++ std::map用迭代器遍历删除遇到的坑](https://blog.csdn.net/zidian666/article/details/125673395)[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_1"}}] [.reference_item style="max-width: 50%"]
- *2* *3* [C++map迭代器最全最容易理解](https://blog.csdn.net/qq_53547805/article/details/122146122)[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_1"}}] [.reference_item style="max-width: 50%"]
[ .reference_list ]