Реализация своего std::vector c аллокатором памяти

#include <cstddef>
#include <memory>
#include <iterator>
#include <initializer_list>
 
#ifndef VECTOR_H
#define VECTOR_H
//-------------------------------------------------------------------------------------------------
namespace htk
{
    template <typename type, typename allocator = std::allocator<type>>
    class vector
    {
    public:
        //Member types
        using value_type             = type;
        using allocator_type         = allocator;
        using size_type              = std::size_t;
        using diference_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;
        class iterator;
        class const_iterator;
        using reverse_iterator       = std::reverse_iterator<iterator>;
        using const_reverse_iterator = std::reverse_iterator<const_iterator>;
 
        //Member functions
        //(constructor)
        vector() noexcept(noexcept(allocator()));
        explicit vector(const allocator_type & alloc) noexcept;
        vector(size_type count, const value_type & value, const allocator_type & alloc = allocator());
        explicit vector(size_type count, const allocator_type & alloc = allocator());
        template<typename InputIt> 
        vector(InputIt first, InputIt last, const allocator_type & alloc = allocator());
        vector(const vector & vec);
        vector(const vector & other, const allocator_type & alloc);
        vector(vector&& other) noexcept;
        vector(vector && other, const allocator_type & alloc);
        vector(std::initializer_list<type> init, const allocator_type & alloc = allocator());
        
        //(destructor)
        ~vector();
 
        //(operator)
        vector & operator = (const vector & vec);
        vector & operator = (vector && vec);
 
 
        allocator_type get_allocator() const;
 
    private:
        allocator_type v_alloc;
        size_type v_size;
        size_type v_capacity;
        pointer v_storage;
    };
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::vector() noexcept(noexcept(allocator())) : 
        v_alloc(), v_size(0), v_capacity(2), v_storage(nullptr)
    {
        //Body of the constructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::vector(const allocator_type & alloc) noexcept :
        v_alloc(alloc), v_size(0), v_capacity(2), v_storage(nullptr)
    {
        //Body of the constructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::vector(size_type count, const value_type & value,
        const allocator_type & alloc) :
        v_alloc(alloc), v_size(count), v_capacity(v_size * 2), v_storage(v_alloc.allocate(v_capacity))
    {
        std::uninitialized_fill_n(v_storage, v_size, value);
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::vector(size_type count, const allocator_type & alloc) :
        v_alloc(alloc), v_size(count), v_capacity(v_size * 2), v_storage(nullptr)
    {
        //Body of the constructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    template<typename InputIt>
    vector<type, allocator>::vector(InputIt first, InputIt last, const allocator_type & alloc) :
        v_alloc(alloc), v_size(count), v_capacity(v_size * 2), v_storage(v_alloc.allocate(v_capacity))
    {
        //Body of the constructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::vector(const vector & vec) : 
        v_alloc(vec.v_alloc), v_size(vec.count), v_capacity(vec.v_capacity), v_storage(nullptr)
    {
        //Body of the constructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::vector(const vector & other, const allocator_type & alloc) :
        v_alloc(alloc), v_size(0), v_capacity(2), v_storage(nullptr)
    {
        //Body of the constructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::vector(vector && other) noexcept :
        v_alloc(other.v_alloc), v_size(other.v_size), v_capacity(other.v_capacity), v_storage(other.v_storage)
    {
        //Body of the constructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::vector(vector && other, const allocator_type & alloc) :
        v_alloc(alloc), v_size(0), v_capacity(2), v_storage(nullptr)
    {
        //Body of the constructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::vector(std::initializer_list<type> init, const allocator_type & alloc) :
        v_alloc(alloc), v_size(0), v_capacity(2), v_storage(nullptr)
    {
        //Body of the constructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator>::~vector()
    {
        //Body of the destructor class
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator> & vector<type, allocator>::operator = (const vector & vec)
    {
        return;
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    vector<type, allocator> & vector<type, allocator>::operator = (vector && vec)
    {
        return;
    }
    //-------------------------------------------------------------------------------------------------
    template <typename type, typename allocator>
    typename vector<type, allocator>::allocator_type vector<type, allocator>::get_allocator() const
    {
 
    }
    //-------------------------------------------------------------------------------------------------
}
#endif // VECTOR_H