(構造函數)	構造 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 
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 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 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 
    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)...);
        ++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(::operator new(sizeof(T) * n));
    }
    void dealloc(T *p) noexcept //釋放內存
    {
        ::operator delete(p);
    }
    template 
    void construct(T *p, Args &&...args) //在這塊內存上構造T類型對象
    {
        ::new (p) T(std::forward(args)...);
    }
    void destroy(T *p) noexcept
    {
        p->~T();
    }

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