Create a new version of paste:

#ifndef VECTOR_H
#define VECTOR_H

#include <iterator>
#include <cstddef>
#include <string>
#include <type_traits>
#include <utility>
#include <initializer_list>

template<typename T>
class vector
{
public:
    typedef T                                       value_type;
    typedef value_type*                             iterator;
    typedef const value_type*                       const_iterator;
    typedef value_type&                             reference;
    typedef const value_type&                       const_reference;
    typedef std::reverse_iterator<iterator>         reverse_iterator;
    typedef std::reverse_iterator<const_iterator>   const_reverse_iterator;
    typedef std::size_t                             size_type;
    typedef std::ptrdiff_t                          difference_type;

    explicit vector() : __base(nullptr), __size(0), __capacity(0) {}
    explicit vector(size_type n) : __base(nullptr), __size(n), __capacity(__size << 1)
    {
        __base = new value_type[__capacity];
        for(size_type __c = 0; __c != __size; ++__c)
            __base[__c] = value_type{};
    }
    explicit vector(size_type n, const value_type& val) : __base(nullptr), __size(n), __capacity(__size << 1)
    {
        __base = new value_type[__capacity];
        for(size_type __c = 0; __c != __size; ++__c)
            __base[__c] = val;
    }

    vector(const vector& x) : __size(x.__size), __capacity(x.__capacity)
    {
        delete [] __base;
        __base = new value_type[__capacity];
        for(size_type __c = 0; __c != __size; ++__c)
            __base[__c] = x.__base[__c];
    }
    vector(vector&& x) : __base(std::move(x.__base)), __size(std::move(x.__size)), __capacity(std::move(x.__capacity))
    {
        x.__base = nullptr;
        x.__size = 0;
        x.__capacity = 0;
    }
    vector(std::initializer_list<value_type> il) : __size(il.size()), __capacity(__size << 1)
    {
        delete [] __base;
        __base = new value_type[__capacity];
        typename std::initializer_list<value_type>::iterator itr = il.begin();
        typename std::initializer_list<value_type>::iterator end = il.end();
        for(size_type __c = 0; __c != __size && itr != end; ++__c, ++itr)
            __base[__c] = *itr;
    }
    
    ~vector()
    {
        delete [] __base;
        __size = 0;
        __capacity = 0;
    }

    vector& operator=(const vector& x)
    {
        delete [] __base;
        __base = new value_type[__capacity];
        __size = x.__size;
        __capacity = x.__capacity;
        for(size_type __c = 0; __c != __size; ++__c)
            __base[__c] = x.__base[__c];
        return *this;
    }
    vector& operator=(vector&& x)
    {
        __base = std::move(x.__base);
        __size = std::move(x.__size);
        __capacity = std::move(x.__capacity);
        x.__base = nullptr;
        x.__size = 0;
        x.__capacity = 0;
        return *this;
    }
    vector& operator=(std::initializer_list<value_type> il)
    {
        delete [] __base;
        __base = new value_type[__capacity];
        __size = il.size();
        __capacity = (__size << 1);
        typename std::initializer_list<value_type>::iterator itr = il.begin();
        typename std::initializer_list<value_type>::iterator end = il.end();
        for(size_type __c = 0; __c != __size && itr != end; ++__c, ++itr)
            __base[__c] = *itr;
        return *this;
    }

    iterator begin() noexcept { return iterator(std::addressof(__base[0])); }
    const_iterator begin() const noexcept { return const_iterator(std::addressof(__base[0])); }

    iterator end() noexcept { return iterator(std::addressof(__base[__size])); }
    const_iterator end() const noexcept { return const_iterator(std::addressof(__base[__size])); }

    reverse_iterator rbegin() noexcept { return reverse_iterator(std::addressof(__base[__size])); }
    const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(std::addressof(__base[__size])); }

    reverse_iterator rend() noexcept { return reverse_iterator(std::addressof(__base[0])); }
    const_reverse_iterator rend() const noexcept { return const_reverse_iterator(std::addressof(__base[0])); }

    const_iterator cbegin() const noexcept { return const_iterator(std::addressof(__base[0])); }
    const_iterator cend() const noexcept { return const_iterator(std::addressof(__base[__size])); }

    const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(std::addressof(__base[__size])); }
    const_reverse_iterator crend() const noexcept { return const_reverse_iterator(std::addressof(__base[0])); }

    size_type size() const noexcept { return __size; }
    size_type max_size() const noexcept {
        difference_type __PTRDIFF_T_MAX__ = 1;
        __PTRDIFF_T_MAX__ <<= ((sizeof(difference_type) * 8) - 1);
        return __PTRDIFF_T_MAX__ - 1;
    }
    size_type capacity() const noexcept { return __capacity; }

    void resize(size_type n)
    {
        if(n < __size)
        {
            __size = n;
            std::destroy(std::addressof(__base[n]), std::addressof(__base[__size]));
        }
        else if(n == __size)
            return;
        else
        {
            if(__capacity < n)
            {
                __capacity = n;
                value_type* __tmp_base = new value_type[__capacity];
                for(size_type __c = 0; __c != __size; ++__c)
                    __tmp_base[__c] = __base[__c];
                delete [] __base;
                __base = __tmp_base;
            }
            for(size_type __c = __size; __c != n; ++__c)
                __base[__c] = value_type{};
            __size = n;
        }
    }
    void resize(size_type n, const value_type& val)
    {
        if(n < __size)
        {
            __size = n;
            std::destroy(std::addressof(__base[n]), std::addressof(__base[__size]));
        }
        else if(n == __size)
            return;
        else
        {
            if(n > __capacity)
            {
                __capacity = n;
                value_type* __tmp_base = new value_type[__capacity];
                for(size_type __c = 0; __c != __size; ++__c)
                    __tmp_base[__c] = __base[__c];
                delete [] __base;
                __base = __tmp_base;
            }
            for(size_type __c = __size; __c != n; ++__c)
                __base[__c] = val;
            __size = n;
        }
    }

    void reserve(size_type n)
    {
        if(n > __capacity)
        {
            __capacity = n << 1;
            value_type* __tmp_base = new value_type[__capacity];
            for(size_type __c = 0; __c != __size; ++__c)
                __tmp_base[__c] = __base[__c];
            delete [] __base;
            __base = __tmp_base;
        }
    }
    void shrink_to_fit()
    {
        if(__capacity != __size)
        {
            __capacity = __size;
            std::destroy(std::addressof(__base[__size]), std::addressof(__base[__capacity]));
        }
    }

    bool empty() const noexcept { return __size == 0 && begin() == end(); }

    reference operator[](size_type n) { return __base[n]; }
    const_reference operator[](size_type n) const { return __base[n]; }

    reference at(size_type n)
    {
        if(n < __size)
            return __base[n];
        else
        {
            std::string __prelouge = "vector::_M_range_check: __n (which is ";
            std::string __inlouge = ") >= this->size() (which is ";
            std::string __prolouge = ")";
            std::string msg = __prelouge + std::to_string(n) + __inlouge + std::to_string(__size) + __prolouge;
            throw std::out_of_range(msg);
        }
    }
    const_reference at(size_type n) const
    {
        if(n < __size)
            return __base[n];
        else
        {   
            std::string __prelouge = "vector::_M_range_check: __n (which is ";
            std::string __inlouge = ") >= this->size() (which is ";
            std::string __prolouge = ")";
            std::string msg = __prelouge + std::to_string(n) + __inlouge + std::to_string(__size) + __prolouge;
            throw std::out_of_range(msg);
        }
    }

    reference front() {
        if(empty())
            throw std::out_of_range("vector::_M_range_check: container empty : this->size() (which is 0)");
        else
            return reference(__base[0]);
    }
    const_reference front() const
    {
        if(empty())
            throw std::out_of_range("vector::_M_range_check: container empty : this->size() (which is 0)");
        else
            return const_reference(__base[0]);
    }

    reference back()
    {
        if(empty())
            throw std::out_of_range("vector::_M_range_check: container empty : this->size() (which is 0)");
        else
            return reference(__base[__size - 1]);
    }
    const_reference back() const
    {
        if(empty())
            throw std::out_of_range("vector::_M_range_check: container empty : this->size() (which is 0)");
        else
            return reference(__base[__size - 1]);
    }

    value_type* data() { return __base; }
    const value_type* data() const { return __base; }

    void assign(size_type n, const value_type& val)
    {
        delete [] __base;
        __base = new value_type[__capacity];
        __size = n;
        __capacity = (__size << 1);
        for(size_type __c = 0; __c != __size; ++__c)
            __base[__c] = val;
    }
    void assign(std::initializer_list<value_type> il)
    {
        delete [] __base;
        __base = new value_type[__capacity];
        __size = il.size();
        __capacity = (__size << 1);
        typename std::initializer_list<value_type>::iterator itr = il.begin();
        typename std::initializer_list<value_type>::iterator end = il.end();
        for(size_type __c = 0; __c != __size && itr != end; ++__c, ++itr)
            __base[__c] = *itr;
    }

    void push_back(const value_type& val)
    {
        if(__size == __capacity)
        {
            if(__size == 0) __capacity = 1;
            else __capacity = (__size << 1);
            value_type* __tmp_base = new value_type[__capacity];
            for(size_type __c = 0; __c != __size; ++__c)
                __tmp_base[__c] = __base[__c];
            delete [] __base;
            __base = __tmp_base;
        }
        __base[__size] = val;
        ++__size;
    }
    void push_back(value_type&& val)
    {
        if(__size == __capacity)
        {
            if(__size == 0) __capacity = 1;
            else __capacity = (__size << 1);
            value_type* __tmp_base = new value_type[__capacity];
            for(size_type __c = 0; __c != __size; ++__c)
                __tmp_base[__c] = __base[__c];
            delete [] __base;
            __base = __tmp_base;
        }
        __base[__size] = std::move(val);
        ++__size;
    }

    void pop_back()
    {
        if(empty())
            throw std::out_of_range("vector::_M_range_check: container empty : this->size() (which is 0)");
        else
        {
            std::destroy(std::addressof(__base[__size - 1]), std::addressof(__base[__size]));
            --__size;
        }
    }

    iterator insert(const_iterator position, const value_type& val)
    {
        size_type __pos = position - begin();
        if(__size == __capacity)
        {
            if(__size == 0) __capacity = 1;
            else __capacity = (__size << 1);
            value_type* __tmp_base = new value_type[__capacity];
            for(size_type __c = 0; __c != __size; ++__c)
                __tmp_base[__c] = __base[__c];
            delete [] __base;
            __base = __tmp_base;
        }
        for(size_type __c = __size; __c != __pos; --__c)
            __base[__c] = __base[__c - 1];
        __base[__pos] = val;
        ++__size;
        return iterator(std::addressof(__base[__pos]));
    }
    iterator insert(const_iterator position, value_type&& val)
    {
        size_type __pos = position - begin();
        if(__size == __capacity)
        {
            if(__size == 0) __capacity = 1;
            else __capacity = (__size << 1);
            value_type* __tmp_base = new value_type[__capacity];
            for(size_type __c = 0; __c != __size; ++__c)
                __tmp_base[__c] = __base[__c];
            delete [] __base;
            __base = __tmp_base;
        }
        for(size_type __c = __size; __c != __pos; --__c)
            __base[__c] = __base[__c - 1];
        __base[__pos] = std::move(val);
        ++__size;
        return iterator(std::addressof(__base[__pos]));
    }
    iterator insert(const_iterator position, size_type n, const value_type& val)
    {
        size_type __pos = position - begin();
        if(__size + n > __capacity)
        {
            if(__size == 0) __capacity = (n << 1);
            else __capacity = ((__size + n) << 1);
            value_type* __tmp_base = new value_type[__capacity];
            for(size_type __c = 0; __c != __size; ++__c)
                __tmp_base[__c] = __base[__c];
            delete [] __base;
            __base = __tmp_base;
        }
        for(size_type __c = __size + n - 1; __c != __pos + n - 1; --__c)
            __base[__c] = __base[__c - n];
        for(size_type __c = __pos; __c != (__pos + n); ++__c)
            __base[__c] = val;
        __size += n;
        return iterator(std::addressof(__base[__pos]));
    }
    iterator insert(const_iterator position, std::initializer_list<value_type> il)
    {
        size_type __pos = position - begin();
        size_type n = il.size();
        if(__size + n > __capacity)
        {
            if(__size == 0) __capacity = (n << 1);
            else __capacity = ((__size + n) << 1);
            value_type* __tmp_base = new value_type[__capacity];
            for(size_type __c = 0; __c != __size; ++__c)
                __tmp_base[__c] = __base[__c];
            delete [] __base;
            __base = __tmp_base;
        }
        for(size_type __c = __size + n - 1; __c != __pos + n - 1; --__c)
            __base[__c] = __base[__c - n];
        typename std::initializer_list<value_type>::iterator itr = il.begin();
        typename std::initializer_list<value_type>::iterator end = il.end();
        for(size_type __c = __pos; __c != (__pos + n) && itr != end; ++__c, ++itr)
            __base[__c] = *itr;
        __size += n;
        return iterator(std::addressof(__base[__pos]));
    }
    template<class InputIterator>
    typename std::enable_if<std::is_pointer<InputIterator>::value, iterator>::type
    insert(const_iterator position, InputIterator first, InputIterator last)
    {
        size_type __pos = position - begin();
        size_type n = last - first;
        if(__size + n > __capacity)
        {
            if(__size == 0) __capacity = (n << 1);
            else __capacity = ((__size + n) << 1);
            value_type* __tmp_base = new value_type[__capacity];
            for(size_type __c = 0; __c != __size; ++__c)
                __tmp_base[__c] = __base[__c];
            delete [] __base;
            __base = __tmp_base;
        }
        for(size_type __c = __size + n - 1; __c != __pos + n - 1; --__c)
            __base[__c] = __base[__c - n];
        iterator itr = first;
        for(size_type __c = __pos; __c != (__pos + n) && itr != last; ++__c, ++itr)
            __base[__c] = *itr;
        __size += n;
        return iterator(std::addressof(__base[__pos]));
    }

    iterator erase(const_iterator position)
    {
        if(empty())
            throw std::out_of_range("vector::_M_range_check: container empty : this->size() (which is 0)");
        else
        {
            size_type __pos = position - begin();
            for(size_type __c = __pos; __c != __size - 1; ++__c)
                __base[__c] = __base[__c + 1];
            --__size;
            return iterator(std::addressof(__base[__pos]));
        }
    }
    iterator erase(const_iterator first, const_iterator last)
    {
        if(empty())
            throw std::out_of_range("vector::_M_range_check: container empty : this->size() (which is 0)");
        else
        {
            size_type n = last - first;
            size_type __pos = first - begin();
            for(size_type __c = __pos; __c != __size - n; ++__c)
                __base[__c] = __base[__c + n];
            __size -= n;
            return iterator(std::addressof(__base[__pos]));
        }
    }

    void swap(vector& x)
    {
        if(*this == x) return;
        std::swap(*this, x);
    }

    void clear() noexcept
    {
        if(__size == 0) return;
        delete [] __base;
        __base = new value_type[__capacity];
        __size = 0;
    }

    bool operator==(const vector& rhs)
    {
        if(__size != rhs.__size) return false;
        for(size_type __c = 0; __c != __size; ++__c)
            if(__base[__c] != rhs.__base[__c])
                return false;
        return true;
    }
    bool operator!=(const vector& rhs)
    {
        if(__size != rhs.__size) return true;
        for(size_type __c = 0; __c != __size; ++__c)
            if(__base[__c] != rhs.__base[__c])
                return true;
        return false;
    }
    bool operator<(const vector& rhs)
    {
        return std::lexicographical_compare(this->begin(), this->end(), rhs.begin(), rhs.end());
    }
    bool operator<=(const vector& rhs)
    {
        return !(std::lexicographical_compare(rhs.begin(), rhs.end(), this->begin(), this->end()));
    }
    bool operator>(const vector& rhs)
    {
        return std::lexicographical_compare(rhs.begin(), rhs.end(), this->begin(), this->end());
    }
    bool operator>=(const vector& rhs)
    {
        return !(std::lexicographical_compare(this->begin(), this->end(), rhs.begin(), rhs.end()));
    }

private:
    value_type* __base;
    size_type __size;
    size_type __capacity;
};

#endif