template <typename T>
class Vector
{
public:
   	using Iterator = T*;
   	using size_type = unsigned int;

   	Vector();
   	Vector(size_type n, const T& initial);
   	Vector(const Vector<T>& v);
   	Vector(Vector<T>&& v);
   	Vector<T>& operator= (const Vector<T>& v);
   	Vector<T>& operator= (Vector<T>&& v);
   	~Vector();

   	size_type size() const;
   	size_type capacity() const;
   	bool empty() const;
   	void reserve(size_type n);

   	Iterator begin();
   	Iterator end();

   	T& operator[] (size_type n);
   	T& at(size_type n);

   	void push_back(const T& value);
   	void pop_back();
   	template<typename... Args>
   	void emplace_back(Args&&... args);
   	Iterator insert(Iterator position, const T& value);
   	Iterator erase(Iterator position);
   	void clear();

   	friend void swap(Vector<T>& first, Vector<T>& second);
private:
   	size_type m_size;
   	size_type m_capacity;
   	char* m_buffer;
};

template <typename T>
Vector<T>::Vector()
   	: m_size(0)
   	, m_capacity(1)
   	, m_buffer(new char[sizeof(T) * m_capacity])
{

}

template <typename T>
Vector<T>::Vector(size_type n, const T& initial)
   	: m_size(n)
   	, m_capacity(2 * n)
   	, m_buffer(new char[sizeof(T) * m_capacity])
{
   	for (size_type i = 0; i < m_size; i++)
   	{
          	new (m_buffer + sizeof(T) * i) T(initial);
   	}
}

template <typename T>
Vector<T>::Vector(const Vector<T> &v)
   	: m_size(v.m_size)
   	, m_capacity(v.m_capacity)
   	, m_buffer(new char [sizeof(T) * m_capacity])
{
   	for (auto i = 0; i < m_size; i++)
   	{
          	new (m_buffer + sifeof(T) * i) T(v[i]);
   	}
}

template <typename T>
Vector<T>::Vector(Vector<T>&& v)
   	: m_size(v.m_size)
   	, m_capacity(v.m_capacity)
   	, m_buffer(v.m_buffer)
{
   	v.m_buffer = nullptr;
}

template <typename T>
Vector<T>& Vector<T>::operator=(Vector<T> v)
{
   	swap(*this, v);
   	return *this;
}

template <typename T>
Vector<T>& Vector<T>::operator=(Vector<T>&& v)
{
   	if (this != &v)
   	{
          	delete[] m_buffer;
          	m_size = v.m_size;
          	m_capacity = v.m_capacity;
          	m_buffer = v.m_buffer;
          	v.m_buffer = nullptr;
   	}
   	return *this;
}

template <typename T>
Vector<T>::~Vector()
{
   	delete[] m_buffer;
}

template <typename T>
typename Vector<T>::size_type Vector<T>::size() const
{
   	return m_size;
}

template <typename T>
typename Vector<T>::size_type Vector<T>::capacity() const
{
   	return m_capacity;
}

template <typename T>
bool Vector<T>::empty() const
{
   	return m_size == 0;
}

template <typename T>
void Vector<T>::reserve(size_type n)
{
   	if (n <= m_capacity)
   	{
          	return;
   	}
   	m_capacity = n;
   	char* new_buffer = new char[sizeof(T) * m_capacity];
   	for (size_type i = 0; i < m_size; i++)
   	{
          	new (new_buffer + sizeof(T) * i) T((*this)[i]);
   	}
   	delete[] m_buffer;
   	m_buffer = new_buffer;
}

template <typename T>
typename Vector<T>::Iterator Vector<T>::begin()
{
   	return reinterpret_cast<T*>(m_buffer);
}

template <typename T>
typename Vector<T>::Iterator Vector<T>::end()
{
   	return reinterpret_cast<T*>(m_buffer) + m_size;
}

template <typename T>
T& Vector<T>::operator[](size_type n)
{
   	return reinterpret_cast<T*>(m_buffer)[n];
}

template <typename T>
T& Vector<T>::at(size_type n)
{
   	if (n >= m_size)
   	{
          	throw std::out_of_range("Out of range");
   	}
   	return reinterpret_cast<T*>(m_buffer)[n];
}

template <typename T>
void Vector<T>::push_back(const T& value)
{
   	if (m_size >= m_capacity)
   	{
          	reserve(2 * m_size);
   	}
   	new (end()) T(value);
   	++m_size;
}

template <typename T>
void Vector<T>::pop_back()
{
   	(*this)[m_size - 1]->~T();
   	--m_size;
}

template <typename T>
template <typename... Args>
void Vector<T>::emplace_back(Args&& ...args)
{
   	if (m_size >= m_capacity)
   	{
          	reserve(2 * m_size);
   	}
   	new(end()) T(std::forward<Args>(args)...);

}

template <typename T>
typename Vector<T>::Iterator Vector<T>::insert(Iterator position, const T& value)
{
   	if (m_size >= m_capacity)
   	{
          	reserve(2 * m_capacity);
   	}
   	auto current_position = end();
   	while (current_position != position)
   	{
          	*current_position = *(current_position - 1);
          	--current_position;
   	}
   	*current_position = value;

   	++m_size;
   	return position;
}

template <typename T>
typename Vector<T>::Iterator Vector<T>::erase(Iterator position)
{
   	position->~T();
   	auto current_position = position + 1;
   	while (current_position != end())
   	{
          	*(current_position - 1) = *current_position;
          	++current_position;
   	}
   	--m_size;
   	return position;
}

template <typename T>
void Vector<T>::clear()
{
   	for (size_type i = 0; i < m_size; i++)
   	{
          	(*this)[i]->~T();
   	}
   	m_size = 0;
}

template <typename T>
void swap(Vector<T>& first, Vector<T>& second)
{
   	std::swap(first.m_size, second.m_size);
   	std::swap(first.m_capacity, second.m_capacity);
   	std::swap(first.m_buffer, second.m_buffer);
}

main.cpp

#include <iostream>
#include "Vector.h"


int main()
{
   	Vector<int> v(10, 5);
   	v.push_back(4);
   	v.push_back(7);
   	v.erase(v.begin() + 11);
   	v.insert(v.begin() + 2, 13);
   	for (auto i = 0; i < v.size(); i++)
   	{
          	std::cout << v[i] << std::endl;
   	}
	return 0;
}