C++ vector的简单实现

	(构造函数)	构造 vector(公开成员函数)
	(析构函数)	析构 vector(公开成员函数)
	operator=	赋值给容器(公开成员函数)
	assign	将值赋给容器(公开成员函数)
	get_allocator	返回相关的分配器(公开成员函数)
	
元素访问
	at	访问指定的元素，同时进行越界检查(公开成员函数)
	operator[]	访问指定的元素(公开成员函数)
	front	访问第一个元素(公开成员函数)
	back	访问最后一个元素(公开成员函数)
	data	直接访问底层数组(公开成员函数)
	
迭代器
	begin，cbegin(C++11)	返回指向起始的迭代器(公开成员函数)
	end，cend(C++11)	返回指向末尾的迭代器(公开成员函数)
	rbegin，crbegin(C++11)	返回指向起始的逆向迭代器(公开成员函数)
	rend，crend(C++11)	返回指向末尾的逆向迭代器(公开成员函数)
	
容量
	empty	检查容器是否为空(公开成员函数)
	size	返回容纳的元素数(公开成员函数)
	max_size	返回可容纳的最大元素数(公开成员函数)
	reserve	预留存储空间(公开成员函数)
	capacity	返回当前存储空间能够容纳的元素数(公开成员函数)
	shrink_to_fit(C++11)	通过释放未使用的内存减少内存的使用(公开成员函数)
	
修改器
	clear	清除内容(公开成员函数)
	insert	插入元素(公开成员函数)
	emplace(C++11)	原位构造元素(公开成员函数)
	erase	擦除元素(公开成员函数)
	push_back	将元素添加到容器末尾(公开成员函数)
	emplace_back(C++11)	在容器末尾就地构造元素(公开成员函数)
	pop_back	移除末元素(公开成员函数)
	resize	改变容器中可存储元素的个数(公开成员函数)
	swap	交换内容(公开成员函数)
	
非成员函数
按照字典顺序比较 vector 中的值(函数模板)
	operator==
	operator!=(C++20 中移除)
	operator<(C++20 中移除)
	operator<=(C++20 中移除)
	operator>(C++20 中移除)
	operator>=(C++20 中移除)
	operator<=>(C++20)
std::swap(std::vector)	特化 std::swap 算法(函数模板)
erase(std::vector)，erase_if(std::vector)  (C++20)	擦除所有满足特定判别标准的元素(函数模板

template <typename T>
class Vector
{
public:
    Vector() noexcept = default;
    explicit Vector(size_t n) : cap_{n}, ptr_{alloc(cap_)}
    {
        for (; len_ < n; ++len_)
        {
            construct(ptr_ + len_); //调用T的默认构造
        }
    }
    Vector(size_t n, const T &x) : cap_{n}, ptr_{alloc(cap_)}
    {
        for (; len_ < n; ++len_)
        {
            construct(ptr_ + len_, x); //调用T的拷贝构造
        }
    }
    Vector(const Vector &x) : cap_{x.size()}, ptr_{alloc(cap_)} //拷贝构造
    {
        for (; len_ < x.size(); ++len_)
        {
            construct(ptr_ + len_, x[len_]);
        }
    }
    Vector(Vector &&x) noexcept //移动构造
    {
        cap_ = std::__exchange(x.cap_, 0);
        len_ = std::__exchange(x.len_, 0);
        ptr_ = std::__exchange(x.ptr_, nullptr);
    }
    Vector(std::initializer_list<T> li) : cap_{li.size()}, ptr_{alloc(cap_)} //初始化列表
    {
        for (auto &x : li)
        {
            construct(ptr_ + len_, x);
            ++len_;
        }
    }

    ~Vector() noexcept
    {
        clear();
        dealloc(ptr_);
    }

    void swap(Vector &x) noexcept
    {
        using std::swap; // ADL
        swap(cap_, x.cap_);
        swap(len_, x.len_);
        swap(ptr_, x.ptr_);
    }
    void clear() noexcept
    {
        for (; len_ > 0; --len_)
        {
            destroy(ptr_ + len_ - 1);
        }
    }

    Vector &operator=(const T &x) //拷贝赋值
    {
        if (this != &x)
        {
            Vector{x}.swap(*this);
        }
        return *this;
    }
    Vector &operator=(T &&x) noexcept //移动赋值
    {
        if (this != &x)
        {
            Vector{std::move(x)}.swap(*this);
        }
        return *this;
    }
    Vector &operator=(std::initializer_list<T> li) //初始化列表赋值
    {
        Vector{li}.swap(*this);
        return *this;
    }

    void push_back(const T &x) //拷贝
    {
        emplace_back(x);
    }
    void push_back(T &&x) //移动
    {
        emplace_back(x);
    }
    template <typename... Args>
    void emplace_back(Args &&...args) //直接传递构造函数
    {
        if (len_ == cap_)
        {
            size_t new_cap = cap_ ? cap_ * 2 : 1; //等0返回1
            T *new_ptr = alloc(new_cap);
            for (size_t new_len; new_len < len_; ++new_len)
            {
                construct(new_ptr + new_len, std::move_if_noexcept(ptr_[new_len]));
            }
            cap_ = new_cap;
            ptr_ = new_ptr;
        }
        construct(ptr_ + len_, std::forward<Args>(args)...);
        ++len_;
    }
    void pop_back() noexcept
    {
        if (len_ < cap_ / 2)
        {
            size_t new_cap = cap_ / 2;
            T *new_ptr = alloc(new_cap);
            for (size_t new_len = 0; new_len < len_; ++new_len)
            {
                construct(new_ptr + new_len, std::move_if_noexcept(ptr_[new_len]));
            }
            cap_ = new_cap;
            ptr_ = new_ptr;
        }
        destroy(ptr_ + len_ - 1);
        --len_;
    }
    size_t size() const noexcept
    {
        return len_;
    }
    size_t capacity() const noexcept
    {
        return cap_;
    }
    bool empty() const noexcept
    {
        return len_ == 0;
    }

    T &operator[](size_t i)
    {
        return ptr_[i];
    }
    const T &operator[](size_t i) const
    {
        return ptr_[i];
    }

    T *begin() noexcept
    {
        return ptr_;
    }
    T *end() noexcept
    {
        return ptr_ + len_;
    }
    const T *begin() const noexcept
    {
        return ptr_;
    }
    const T *end() const noexcept
    {
        return ptr_ + len_;
    }

private:
    T *alloc(size_t n) //分配n个大小内存
    {
        return static_cast<T *>(::operator new(sizeof(T) * n));
    }
    void dealloc(T *p) noexcept //释放内存
    {
        ::operator delete(p);
    }
    template <typename... Args>
    void construct(T *p, Args &&...args) //在这块内存上构造T类型对象
    {
        ::new (p) T(std::forward<Args>(args)...);
    }
    void destroy(T *p) noexcept
    {
        p->~T();
    }

private:
    size_t cap_{0}; //容量
    size_t len_{0}; //元素个数
    T *ptr_{nullptr};
};