C++实现自定义vector(拷贝构造、深拷贝、类模板)

#pragma once
/*自定义容器类*/
#include <iostream>

using namespace std;

template <typename T>
class MyVector
{
public:
	MyVector();
	MyVector(int len, T element);	//填充len长度的元素element
	MyVector(const MyVector<T> &vec);	//拷贝构造
	~MyVector();
	//重载赋值运算符
	MyVector<T> & operator = (const MyVector<T> &vec);
	//重载 [] 运算符
	T & operator [] (int index);	//获取元素
	void push_back(T elment);	//将元素放入element;
	
	T pop_back();	//返回并删除最后一个元素
	void insert(int pos,T element);	//在pos位置处，插入新的元素
	void clear();	//清空所有元素
	
	template<typename T2>		//友元函数重载 << 运算符
	friend ostream &operator << (ostream &out, const MyVector<T2> vec);

private:
	T *m_ptrElement;	//存放元素的数组
	int m_length;		//存放元素的实际个数
	int m_capacity;		//当前元素数组的大小
};

template <typename T>
MyVector<T>::MyVector() : m_capacity(16), m_length(0)//填充len长度的元素element
{
	this->m_ptrElement = new T[m_capacity];
}
template <typename T>
MyVector<T>::~MyVector()
{
	delete[]m_ptrElement;
}
template <typename T>
MyVector<T>::MyVector(int len, T element) :m_capacity(16)
{
	m_capacity += len;
	m_length = len;
	m_ptrElement = new T[m_capacity];
	//使用mencpy拷贝
	for (int i = 0; i < m_length; ++i)
	{
		memcpy(&m_ptrElement[i], &element, sizeof(T));
	}
}
template <typename T>
MyVector<T>::MyVector(const MyVector<T> &vec)	//拷贝构造
{
	m_capacity = vec.m_capacity;
	m_length = vec.m_length;
	m_ptrElement = new T[m_capacity];
	memcpy(m_ptrElement, vec.m_ptrElement, m_length * sizeof(T));
}
//重载赋值运算符
template <typename T>
MyVector<T> & MyVector<T>::operator = (const MyVector<T> &vec)
{
	if (this == &vec) return *this;
	if (nullptr != m_ptrElement)
	{
		delete[]m_ptrElement;
		m_ptrElement = nullptr;
	}
	m_capacity = vec.m_length + vec.m_capacity;
	m_length = vec.m_length;
	m_ptrElement = new T[vec.m_capacity];
	memcpy(m_ptrElement, vec.m_ptrElement, sizeof(T)* vec.m_length);

	return *this;
}
template <typename T>
T & MyVector<T>::operator [] (int index)
{
	return m_ptrElement[index];
}
template <typename T>
void MyVector<T>::push_back(T elment)
{
	//将元素element添加到数组的最后一个位置
	if (nullptr == m_ptrElement)
	{
		m_capacity = 16;
		m_length = 0;
		m_ptrElement = new T[m_capacity];
	}
	//判断当前数组容量是否已满
	if (m_length == m_capacity)
	{
		//如果满了就扩容：当前容量 * 2 + 1
		T *ptrNewElement = new T[m_capacity * 2 + 1];
		//把原来的元素拷贝到新空间中去
		memcpy(ptrNewElement, m_ptrElement, sizeof(T) * m_length);
		//释放空间
		delete[]m_ptrElement;
		//将元素数组的指向指向新空间
		m_ptrElement = ptrNewElement;
	}
	m_ptrElement[m_length++] = elment;
}
template<typename T2>
ostream &operator << (ostream &out, const MyVector<T2> vec)
{
	for (int i = 0; i < vec.m_length; ++i)
	{
		out << vec.m_ptrElement[i] << ",";
	}
	out << endl;
	return out;
}
int main()
{
	MyVector<int> vec;
	MyVector<double> vec1(10, 99.9);

	cout << "vec:" << vec << endl;
	cout << "vec1:" << vec1 << endl;

	vec.push_back(2);
	vec.push_back(5);
	cout << "vec:" << vec << endl;
	system("pause");
    return 0;
}