[JavaScript知识库]C++实现顺序栈（函数类外实现&&模板）

1.类

const int MAX_SIZE = 100;
template <class DataType>
class stack
{
private:
	DataType* data;//属性：线性表！
	int size;//堆栈实际大小
	int top;//栈顶
	//函数类外表示
public:
	stack();//默认构造函数
	
	stack(int s);//有参构造函数
	
	~stack();//析构函数
	
	void push(DataType ch);//入栈
	
	DataType pop();//出栈并返回栈顶元素
	
	DataType getTop();//获得栈顶元素但不出栈
	
	bool isEmpty();//判断栈是否为空
	
	bool isFull();//判断栈是否满
	
	void setNull();//设置栈为空！！！！

	//捕捉异常需要设定内部类！！！！！
	class Full {};
	class Empty {};//注意是花括号！！！
};

2.类外实现函数接口

1.无参构造函数

//无参构造函数
stack<DataType>::stack() 
{
	size = MAX_SIZE;
	top = -1;
	data = new DataType[MAX_SIZE];
}

2.有参构造函数

//有参构造函数
template <class DataType>
stack<DataType>::stack(int s) {
	size = s;
	top = -1;
	data = new DataType[size];
}

3.//析构函数，释放堆区数据

//析构函数，释放堆区数据
template <class DataType>
stack<DataType>::~stack()
{
	delete []data;//内存回收 释放new创建data占用的内存

	cout << "析构函数finished delete\n";
}

4.//入栈操作

//入栈操作
template <class DataType>
void stack<DataType>::push(DataType ch) {
	if (isFull())
		throw stack<DataType>::Full();//若栈已满，再进行入栈操作，则抛出异常
	else
		data[++top] = ch;
	//return true;
}

5.//出栈操作

//出栈操作
template <class DataType>
DataType stack<DataType>::pop() {
	if (isEmpty())
		throw stack<DataType>::Empty();//若栈为空，再进行出栈操作，则抛出异常
	else
		return data[top--];
}

6.//得到栈顶元素

//得到栈顶元素
template <class DataType>
DataType stack<DataType>::getTop() 
{
	if (!isEmpty())
		return data[top];
}

7.//判断栈是否为空

//判断栈是否为空
template <class DataType>
bool stack<DataType>::isEmpty() 
{
	if (top == -1) {
		return true;
	}
	else {
		return false;
	}
}

8.//判断栈是否满了

//判断栈是否满了
template <class DataType>
bool stack<DataType>::isFull() {
	if (top == size - 1) {
		return true;
	}
	else {
		return false;
	}
}

9.//设置栈为空！！！！

//设置栈为空！！！！
template <class DataType>
void stack<DataType>::setNull() {
	top = -1;
	cout << "top=-1!\n";
}

3.stack.cpp

#include "stack.hpp"
#include <iostream>
using namespace std;

int main() {
	stack<char> st(2);
	//stack<char> st(2);//利用两者均可构造函数初始化
	char ch;
	try {
		st.push('a');
		st.push('b');
		st.push('c');
	}
	catch (stack<char>::Full) {//注意!!!此处FULL后面不需要括号！！！！！
		cout << "stack full!\n";
	}
	try {
		ch = st.pop();
		cout << ch << endl;
		ch = st.pop();
		cout << ch << endl;
		ch = st.pop();
		cout << ch << endl;
	}
	catch (stack<char>::Empty) //若栈为空，再进行出栈操作，则抛出异常
	{
		cout << "stack empty!\n";
	}

	double c;
	stack<double> sl(2);
	try {
		sl.push(1998.3);
		sl.push(1999.9);
		sl.push(2000.1);
	}
	catch (stack<double>::Full) {//注意!!!此处FULL后面不需要括号！！！！！
		cout << "stack full!\n";
	}
	try {
		c = sl.pop();
		cout << c << endl;
		c = sl.pop();
		cout << c << endl;
		c = sl.pop();
		cout << c << endl;
	}
	catch (stack<double>::Empty) {
		cout << "stack empty!\n";
	}
	return 0;
}

4.总源码（分文件）

1.stack.hpp

#pragma once
const int MAX_SIZE = 100;
template <class DataType>
class stack
{
private:
	DataType* data;//属性：线性表！
	int size;//堆栈实际大小
	int top;//栈顶
	//函数类外表示
public:
	stack();//默认构造函数
	stack(int s);//有参构造函数
	~stack();//析构函数
	void push(DataType ch);//入栈
	DataType pop();//出栈并返回栈顶元素
	DataType getTop();//获得栈顶元素但不出栈
	bool isEmpty();//判断栈是否为空
	bool isFull();//判断栈是否满
	void setNull();//设置栈为空！！！！

	//捕捉异常需要设定内部类！！！！！
	class Full {};
	class Empty {};//注意是花括号！！！
};
//#endif
#include <iostream>
using namespace std;
template <class DataType>
//无参构造函数
stack<DataType>::stack() 
{
	size = MAX_SIZE;
	top = -1;
	data = new DataType[MAX_SIZE];
}
//有参构造函数
template <class DataType>
stack<DataType>::stack(int s) {
	size = s;
	top = -1;
	data = new DataType[size];
}
//析构函数，释放堆区数据
template <class DataType>
stack<DataType>::~stack()
{
	delete []data;//内存回收 释放new创建data占用的内存

	cout << "析构函数finished delete\n";
}
//入栈操作
template <class DataType>
void stack<DataType>::push(DataType ch) {
	if (isFull())
		throw stack<DataType>::Full();//若栈已满，再进行入栈操作，则抛出异常
	else
		data[++top] = ch;
	//return true;
}
//出栈操作
template <class DataType>
DataType stack<DataType>::pop() {
	if (isEmpty())
		throw stack<DataType>::Empty();//若栈为空，再进行出栈操作，则抛出异常
	else
		return data[top--];
}
//得到栈顶元素
template <class DataType>
DataType stack<DataType>::getTop() 
{
	if (!isEmpty())
		return data[top];
}
//判断栈是否为空
template <class DataType>
bool stack<DataType>::isEmpty() 
{
	if (top == -1) {
		return true;
	}
	else {
		return false;
	}
}
//判断栈是否满了
template <class DataType>
bool stack<DataType>::isFull() {
	if (top == size - 1) {
		return true;
	}
	else {
		return false;
	}
}
//设置栈为空！！！！
template <class DataType>
void stack<DataType>::setNull() {
	top = -1;
	cout << "top=-1!\n";
}

2.stack.cpp

#include "stack.hpp"
#include <iostream>
using namespace std;

int main() {
	stack<char> st(2);
	//stack<char> st(2);//利用两者均可构造函数初始化
	char ch;
	try {
		st.push('m');
		st.push('k');
		st.push('v');
	}
	catch (stack<char>::Full) {//注意!!!此处FULL后面不需要括号！！！！！
		cout << "stack full!\n";
	}
	try {
		ch = st.pop();
		cout << ch << endl;
		ch = st.pop();
		cout << ch << endl;
		ch = st.pop();
		cout << ch << endl;
	}
	catch (stack<char>::Empty) //若栈为空，再进行出栈操作，则抛出异常
	{
		cout << "stack empty!\n";
	}

	double c;
	stack<double> sl(2);
	try {
		sl.push(6165.2);
		sl.push(65.2);
		sl.push(12.888);
	}
	catch (stack<double>::Full) {//注意!!!此处FULL后面不需要括号！！！！！
		cout << "stack full!\n";
	}
	try {
		c = sl.pop();
		cout << c << endl;
		c = sl.pop();
		cout << c << endl;
		c = sl.pop();
		cout << c << endl;
	}
	catch (stack<double>::Empty) {
		cout << "stack empty!\n";
	}
	return 0;
}

5,总源码（单文件）

#include <iostream>
using namespace std;
const int MAX_SIZE = 100;
template <class DataType>
class stack
{
private:
	DataType* data;//属性：线性表！
	int size;//堆栈实际大小
	int top;//栈顶
	//函数类外表示
public:
	stack();//默认构造函数
	stack(int s);//有参构造函数
	~stack();//析构函数
	void push(DataType ch);//入栈
	DataType pop();//出栈并返回栈顶元素
	DataType getTop();//获得栈顶元素但不出栈
	bool isEmpty();//判断栈是否为空
	bool isFull();//判断栈是否满
	void setNull();//设置栈为空！！！！

	//捕捉异常需要设定内部类！！！！！
	class Full {};
	class Empty {};//注意是花括号！！！
};
template <class DataType>
//无参构造函数
stack<DataType>::stack()
{
	size = MAX_SIZE;
	top = -1;
	data = new DataType[MAX_SIZE];
}
//有参构造函数
template <class DataType>
stack<DataType>::stack(int s) {
	size = s;
	top = -1;
	data = new DataType[size];
}
//析构函数，释放堆区数据
template <class DataType>
stack<DataType>::~stack()
{
	delete[]data;//内存回收 释放new创建data占用的内存

	cout << "析构函数finished delete\n";
}
//入栈操作
template <class DataType>
void stack<DataType>::push(DataType ch) {
	if (isFull())
		throw stack<DataType>::Full();//若栈已满，再进行入栈操作，则抛出异常
	else
		data[++top] = ch;
	//return true;
}
//出栈操作
template <class DataType>
DataType stack<DataType>::pop() {
	if (isEmpty())
		throw stack<DataType>::Empty();//若栈为空，再进行出栈操作，则抛出异常
	else
		return data[top--];
}
//得到栈顶元素
template <class DataType>
DataType stack<DataType>::getTop()
{
	if (!isEmpty())
		return data[top];
}
//判断栈是否为空
template <class DataType>
bool stack<DataType>::isEmpty()
{
	if (top == -1) {
		return true;
	}
	else {
		return false;
	}
}
//判断栈是否满了
template <class DataType>
bool stack<DataType>::isFull() {
	if (top == size - 1) {
		return true;
	}
	else {
		return false;
	}
}
//设置栈为空！！！！
template <class DataType>
void stack<DataType>::setNull() {
	top = -1;
	cout << "top=-1!\n";
}

int main() {
	stack<char> st(2);
	//stack<char> st(2);//利用两者均可构造函数初始化
	char ch;
	try {
		st.push('m');
		st.push('k');
		st.push('v');
	}
	catch (stack<char>::Full) {//注意!!!此处FULL后面不需要括号！！！！！
		cout << "stack full!\n";
	}
	try {
		ch = st.pop();
		cout << ch << endl;
		ch = st.pop();
		cout << ch << endl;
		ch = st.pop();
		cout << ch << endl;
	}
	catch (stack<char>::Empty) //若栈为空，再进行出栈操作，则抛出异常
	{
		cout << "stack empty!\n";
	}

	double c;
	stack<double> sl(2);
	try {
		sl.push(6165.2);
		sl.push(65.2);
		sl.push(12.888);
	}
	catch (stack<double>::Full) {//注意!!!此处FULL后面不需要括号！！！！！
		cout << "stack full!\n";
	}
	try {
		c = sl.pop();
		cout << c << endl;
		c = sl.pop();
		cout << c << endl;
		c = sl.pop();
		cout << c << endl;
	}
	catch (stack<double>::Empty) {
		cout << "stack empty!\n";
	}
	return 0;
}

测试结果