自己实现栈和数组和vector

stack.h

#pragma once

template<class T>
class Stack {
public:
	Stack();
	Stack(const Stack<T> &s);
	~Stack();
	void push(const T& elem);
	void pop();
	const T & top();
	size_t size();
	bool empty();
private:
	T *m_elem;
	int m_top; // 栈顶坐标
};

template<class T>
inline Stack<T>::Stack() {
	m_elem = nullptr;
	m_top = -1;
}

template<class T>
inline Stack<T>::Stack(const Stack<T>& s) {
	this->m_elem = s.m_elem;
	this->m_top = s.m_top;
}

template<class T>
inline Stack<T>::~Stack() {
	m_elem = nullptr;
	delete m_elem;
	m_top = -1;
}

template<class T>
inline void Stack<T>::push(const T& elem) {
	if (this->empty()) {
		m_elem = new T[m_top + 1];
		m_elem[++m_top] = elem;
	}
	else {
		Stack<T> s = *this;
		m_elem = nullptr;
		delete m_elem;
		m_top++;
		m_elem = new T[m_top + 1];
		for (int i = 0; i < m_top + 1; ++i) {
			m_elem[i] = s.m_elem[i];
		}
		m_elem[m_top] = elem;
	}
}

template<class T>
inline void Stack<T>::pop() {
	if (m_top == -1) {
		return;
	}
	m_top--;
}

template<class T>
inline const T & Stack<T>::top()
{
	return m_elem[m_top];
}

template<class T>
inline size_t Stack<T>::size()
{
	return m_top + 1;
}

template<class T>
inline bool Stack<T>::empty() {
	return m_top == -1;
}

vector.h

#pragma once

template<class T>
class Vector {
public:
	Vector();
	Vector(size_t n);
	Vector(const Vector<T> &v);
	~Vector();
	const T& front();
	const T& back();
	void push_back(const T &elem);
	void pop_back();
	void erase(const size_t &index);
	bool empty();
	size_t size();
	T& operator[](size_t index)const;
private:
	T *m_elem;
	size_t m_size;
};

template<class T>
inline Vector<T>::Vector() {
	m_elem = nullptr;
	m_size = 0;
}

template<class T>
inline Vector<T>::Vector(size_t n) {
	this->m_elem = new T[m_size];
	this->m_size = n;
}

template<class T>
inline Vector<T>::Vector(const Vector<T>& v) {
	this->m_elem = v.m_elem;
	this->m_size = v.m_size;
}

template<class T>
inline Vector<T>::~Vector() {
	m_elem = nullptr;
	m_size = 0;
}

template<class T>
inline const T & Vector<T>::front() {
	return m_elem[0];
}

template<class T>
inline const T & Vector<T>::back() {
	return m_elem[m_size - 1];
}

template<class T>
inline void Vector<T>::push_back(const T & elem) {
	m_size++;
	Vector<T> temp = *this;
	m_elem = new T[m_size];
	for (size_t i = 0; i < m_size - 1; ++i) {
		m_elem[i] = temp[i];
	}
	m_elem[m_size - 1] = elem;
}

template<class T>
inline void Vector<T>::pop_back() {
	m_size--;
	Vector<T> temp = *this;
	m_elem = new T[m_size];
	for (size_t i = 0; i < m_size; ++i) {
		m_elem[i] = temp[i];
	}
}

template<class T>
inline void Vector<T>::erase(const size_t & index)
{
	m_size--;
	Vector<T> temp = *this;
	m_elem = new T[m_size];
	size_t j = 0;
	for (size_t i = 0; i <= m_size; ++i) {
		if (i == index) {
			j = i;
			continue;
		}
		m_elem[j++] = temp[i];
	}
}

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

template<class T>
inline size_t Vector<T>::size()
{
	return m_size;
}

template<class T>
inline T& Vector<T>::operator[](size_t index) const {
	return m_elem[index];
}