C++数据结构——链栈

主页有其他数据结构内容（持续更新中）

#include
using namespace std;


template 
struct Node
{
	T data;  //数据域
	Node* next;  //指针域
	
	Node()
	{
		next = nullptr;
	}

	explicit Node(T item, Node* ptr = nullptr)
	{
		data = item;
		next = ptr;
	}
};


template 
class LinkStack
{
	int count;                     //栈的大小
	Node* lstop;          //栈顶指针

public:
	LinkStack();                       //构造函数
	LinkStack(const LinkStack& item);  //拷贝构造函数
	~LinkStack();              //析构函数
	void push(const T& item);            //进栈操作
	void pop();                        //出栈操作
	bool empty()const;                    //判断栈是否为空栈
	int size();                     //获取栈的大小
	T top();                //获取栈顶元素
	LinkStack& operator=(const LinkStack& item);  //赋值运算符重载
};


template 
LinkStack::LinkStack()  //构造函数
{
	lstop = nullptr;
	count = 0;
}


template 
LinkStack::LinkStack(const LinkStack& item)  //拷贝构造函数
{
	Node* new_copy;
	Node* original_node = item.lstop;
	if (original_node == nullptr)
	{
		lstop = nullptr;
	}
	else
	{
		lstop = new_copy = new Node(original_node->data);
		while (original_node->next != nullptr)
		{
			original_node = original_node->next;
			new_copy->next = new Node(original_node->data);
			new_copy = new_copy->next;
		}
	}
	count = item.count;
}


template 
LinkStack::~LinkStack()  //析构函数
{
	while (!empty())
	{
		pop();
	}
}


template 
void LinkStack::push(const T& item)  //插入元素
{
	Node* temp = new Node(item, lstop);
	if (temp == nullptr)    //  未能成功申请到内存(但几乎不会发生)
	{
		cout << "Overflow!" << endl;
	}
	else
	{
		lstop = temp;
	}
	temp = nullptr;
	delete temp;
	count++;
}


template 
void LinkStack::pop()  //弹出元素
{
	if (count == 0)
	{
		cout << "Underflow!" << endl;
	}
	else
	{
		Node* temp = lstop;
		lstop = temp->next;
		temp = nullptr;
		delete temp;
		count--;
	}
}


template 
bool LinkStack::empty()const  //判栈空
{
	return count == 0;
}


template 
int LinkStack::size()  //返回栈的大小
{
	return count;
}


template 
T LinkStack::top()  //返回栈顶元素
{
	if (count == 0)
	{
		cout << "Overflow!" << endl;
	}
	else
	{
		return lstop->data;
	}
}


template 
LinkStack& LinkStack::operator=(const LinkStack& item)  //重载赋值运算符
{
    Node* new_copy;
    Node* original_node = item.lstop;
    if (original_node == nullptr)
    {
        lstop = nullptr;
    }
    else
    {
        lstop = new_copy = new Node(original_node->data);
        while (original_node != nullptr)
        {
            original_node = original_node->next;
            new_copy->next = new Node(original_node->data);
            new_copy = new_copy->next;
        }
    }
    count = item.count;
    return *this;
}


int main()
{
	LinkStack ls;
	for (int i = 0; i < 10; i++)
	{
		ls.push(i);
	}
	cout << "栈的长度为：" << ls.size() << endl;

	LinkStack copy_1 = ls; //  测试重载之后的赋值运算符
	while (!copy_1.empty())
	{
		cout << copy_1.top() << " ";
		copy_1.pop();
	}
	cout << endl;

	LinkStack copy_2 = LinkStack(ls); //  测试拷贝构造函数
    while (!copy_2.empty())
    {
        cout << copy_2.top() << " ";
        copy_2.pop();
    }

	return 0;
}