std::vector reserve resize

`std::vector` 是 C++ 标准库中的动态数组容器，它提供了一种高效且灵活的数据存储方式。`reserve` 和 `resize` 是两个非常重要的方法，它们分别用于预分配内存和调整向量的大小。

1. `reserve(size_type n)` 方法: 这个方法用于预先为 `std::vector` 预留空间。当你知道将来可能会添加大量元素，但不确定何时添加，使用 `reserve` 可以避免频繁的动态内存分配和复制，提高性能。参数 `n` 是你想要预留的空间量。如果当前向量的容量小于 `n`，`reserve` 会直接扩展容器的容量到 `n`。

2. `resize(size_type new_size, const T& value = T())`: 这个方法用于改变向量的大小并可能填充新元素。如果 `new_size` 大于当前容量，它会增加元素直到达到新的大小，如果 `new_size` 小于当前容量，会删除超出的部分（除非指定了 `value`）。你可以传入默认值 `value` 来设置新元素的初始值。

相关问题

std::vector成员函数

C++标准库中的std::vector是一个动态数组，它可以在运行时动态地增加或减少其大小。下面是std::vector的一些常用成员函数：

1. push_back()：在vector的末尾添加一个元素。
2. pop_back()：删除vector的末尾元素。
3. size()：返回vector中元素的数量。
4. empty()：如果vector为空，则返回true，否则返回false。
5. clear()：删除vector中的所有元素。
6. front()：返回vector的第一个元素。
7. back()：返回vector的最后一个元素。
8. insert()：在vector的指定位置插入一个元素。
9. erase()：从vector中删除指定位置的元素。
10. resize()：改变vector的大小。
11. reserve()：为vector分配内存空间。

这些成员函数可以帮助我们方便地操作vector，使得我们可以更加高效地使用动态数组。

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