C++ 模板类实现栈的顺序存储和链式存储

SqStack.h

#pragma once
#include <iostream>
using namespace std;

template <typename T>
class SqStack
{
public:
	SqStack(int m = 0);
	~SqStack();
	void Clear();
	bool Empty();
	int Length();
	T& Top();
	void Pop();
	void Push(const T& e);
private:
	T* m_base;
	int m_top;
	int m_size;
};

template<typename T>
SqStack<T>::SqStack(int m)
{
	m_size = m;
	m_top = 0;
	m_base = new T[m];
}

template<typename T>
SqStack<T>::~SqStack()
{
	if (m_base != NULL)
		delete[] m_base;
}

template<typename T>
void SqStack<T>::Clear()
{
	m_top = 0;
}

template<typename T>
bool SqStack<T>::Empty()
{
	return m_top == 0;
}

template<typename T>
int SqStack<T>::Length()
{
	return m_top;
}

template<typename T>
T& SqStack<T>::Top()
{
	return m_base[m_top - 1];
}

template<typename T>
void SqStack<T>::Pop()
{
	m_top--;
}

template<typename T>
void SqStack<T>::Push(const T& e)
{
	if (m_top >= m_size)
	{
		T* new_base = new T[m_size + 10];
		for (int i = 0; i < m_top; i++)
		{
			new_base[i] = m_base[i];
		}
		delete[] m_base;
		m_base = new_base;
		m_size += 10;
	}
	m_base[m_top++] = e;
}

LinkStack.h

#pragma once
#include <iostream>
using namespace std;

template <typename T>
struct LinkStackNode
{
	T val;
	LinkStackNode* next;
};

template <typename T>
class LinkStack
{
public:
	LinkStack();
	~LinkStack();
	void Clear();
	bool Empty();
	int Length();
	T& Top();
	void Pop();
	void Push(const T& e);
private:
	LinkStackNode<T>* m_top;
	int m_size;
};

template<typename T>
LinkStack<T>::LinkStack()
{
	m_top = new LinkStackNode<T>;
	m_top->next = NULL;
	m_size = 0;
}

template<typename T>
LinkStack<T>::~LinkStack()
{
	LinkStackNode<T>* p = m_top, *tmp;
	while (p->next)
	{
		tmp = p->next;
		delete p;
		p = tmp;
	}
	delete p;
	m_size = 0;
}

template<typename T>
void LinkStack<T>::Clear()
{
	LinkStackNode<T>* p = m_top, * tmp;
	while (p->next)
	{
		tmp = p->next;
		delete p;
		p = tmp;
	}
	delete p;
	p = NULL;
	m_size = 0;
}

template<typename T>
bool LinkStack<T>::Empty()
{
	return m_size == 0;
}

template<typename T>
int LinkStack<T>::Length()
{
	return m_size;
}

template<typename T>
T& LinkStack<T>::Top()
{
	LinkStackNode<T>* p = m_top;
	while (p->next)
	{
		p = p->next;
	}

	return p->val;
}

template<typename T>
void LinkStack<T>::Pop()
{
	LinkStackNode<T>* p = m_top;
	while (p->next->next)
	{
		p = p->next;
	}
	delete p->next;
	p->next = NULL;
	m_size--;
}

template<typename T>
void LinkStack<T>::Push(const T& e)
{
	LinkStackNode<T>* p = m_top, *newNode = new LinkStackNode<T>;
	newNode->val = e;
	newNode->next = NULL;
	while (p->next)
	{
		p = p->next;
	}
	p->next = newNode;
	m_size++;
}

StackTest.cpp

#include <iostream>
#include "SqStack.h"
#include "LinkStack.h"
using namespace std;

int main()
{
	SqStack<int> SqS(10);
	for (int i = 0; i < 10; i++)
	{
		SqS.Push(i + 1);
	}

	while (!SqS.Empty())
	{

		cout << SqS.Top() << " ";
		SqS.Pop();
	}
	cout << endl;

	LinkStack<int> LS;
	for (int i = 0; i < 10; i++)
	{
		LS.Push(i + 1);
	}

	while (!LS.Empty())
	{
		cout << LS.Top() << " ";
		LS.Pop();
	}
	cout << endl;


	return 0;
}