Сделать реализацию vector на шаблонах

#include <iostream>
#include <stdexcept>
 
template<typename T>
class my_vector
{
private:
    T* m_memory;
    size_t m_size;
    size_t m_capacity;
    size_t get_grow_rate() const;
    void check_reallocate();
public:
    my_vector(size_t size, const T& value);
    ~my_vector();
    void push_back(T val);
    size_t size() const { return m_size; }
    T& operator[] (size_t i);
    T& at(size_t i);
    void insert(size_t pos, const T& value);
    void erase(size_t pos);
    void preatty_print();
};
 
template<typename T>
my_vector<T>::my_vector(size_t size, const T& value)
    : m_size(size), m_capacity(size)
{
    m_memory = (T*)::new unsigned char[m_size * sizeof(T)]; //allocate memory
    for (int i = 0; i < m_size; ++i)
        new (&m_memory[i]) T(value); //call constuctor at specify place in memory 
}
 
template<typename T>
my_vector<T>::~my_vector()
{
    for (int i = 0; i < m_size; ++i)
        m_memory[i].~T(); //call destructor
    delete[]((unsigned char*)m_memory); //deallocate memory
}
 
template<typename T>
size_t my_vector<T>::get_grow_rate() const
{
    if (m_capacity < 3)
        return 4;
    else
        return m_capacity + m_capacity / 2;
}
 
template<typename T>
void my_vector<T>::check_reallocate()
{
    if (m_size < m_capacity)
        return;
    size_t new_capacity = get_grow_rate();
    T* new_memory = (T*)::new unsigned char[new_capacity * sizeof(T)];
    for (int i = 0; i < m_size; ++i)
    {
        new (&new_memory[i]) T(m_memory[i]); // copy construct
        m_memory[i].~T(); // destruct old
    }
    m_capacity = new_capacity;
    m_memory = new_memory;
}
 
template<typename T>
void my_vector<T>::push_back(T val)
{
    check_reallocate();
    new (&m_memory[m_size]) T(val);
    ++m_size;
}
 
template<typename T>
T& my_vector<T>::operator[] (size_t i)
{
    return m_memory[i];
}
 
template<typename T>
T& my_vector<T>::at(size_t i)
{
    if (i >= m_size)
        throw std::out_of_range("vector index out of range");
    return operator[] (i);
}
 
template<typename T>
void my_vector<T>::insert(size_t pos, const T& value)
{
    if (pos >= m_size)
        throw std::out_of_range("vector index out of range");
    ++m_size;
    check_reallocate();
    for (int i = m_size - 1; i >= pos; --i)
        new (&m_memory[i]) T(m_memory[i - 1]);
    new (&m_memory[pos]) T(value); //insert
}
 
template<typename T>
void my_vector<T>::erase(size_t pos)
{
    if (pos >= m_size)
        throw std::out_of_range("vector index out of range");
    m_memory[pos].~T(); // erase
 
    for (int i = pos; i < m_size - 1; ++i)
    {
        new (&m_memory[i]) T(m_memory[i+1]); 
        m_memory[i+1].~T();
    }
    --m_size;
}
 
template<typename T>
void my_vector<T>::preatty_print()
{
    for (int i = 0; i < m_size; ++i)
        std::cout << this->operator[](i) << " ";
    std::cout << std::endl;
}
 
void test_vector_with_points()
{
    struct Point { int x; int y; int z; };
 
    my_vector<Point> vp(4, { 1, 2, 3 });
    vp.push_back({ 4,5,6 });
    Point temp;
    temp.x = 11;
    temp.y = 22;
    temp.z = 33;
    vp.push_back(temp);
    for (int i = 0; i < vp.size(); ++i)
        std::cout << "x=" << vp[i].x << " y=" << vp[i].y << " z=" << vp[i].z << "; ";
    std::cout << std::endl;
 
    try
    {
        vp.at(10);
    }
    catch (const std::exception& e)
    {
        std::cout << "exaption!!! " << e.what();
    }
}
 
int main()
{  
    my_vector<int> vi(2, 0);
    vi.push_back(42);
    vi.push_back(101);
    vi.push_back(102);
    vi.push_back(103);
    vi.push_back(104);
    vi.push_back(105);
    std::cout << "size : " << vi.size() << std::endl;
    vi.preatty_print();
 
    vi.erase(6);
    std::cout << "size : " << vi.size() << std::endl;
    vi.preatty_print();
 
    vi.insert(3, 99);
    std::cout << "size : " << vi.size() << std::endl;
    vi.preatty_print();
 
    test_vector_with_points();
}