写一个简单的链式栈

版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/zeqi1991/article/details/82083778

list_stack.h

#ifndef _INCLUDE_LIST_STACK_H__
#define _INCLUDE_LIST_STACK_H__

#include <cassert>
#ifdef _DEBUG
#include <iostream>
#endif

template <typename T>
class Stack
{
public:
    struct LinkNode
    {
        T elem;
        LinkNode* pNext;
    };

    Stack(size_t max_size = 4096);
    ~Stack();
    Stack(const Stack<T>& other);
    Stack<T>& operator = (const Stack<T>& other);
    void push(const T& elem);
    T pop();
    bool empty();
    void clear();
    bool isFull();
    size_t size();
    void show();
private:
    size_t max_size_;
    size_t size_;
    LinkNode* header_;
    LinkNode* tail_;
};

template <typename T>
Stack<T>::Stack(size_t max_size) : max_size_(max_size),
                                            size_(0),
                                            header_(nullptr),
                                            tail_(nullptr)
{

}

template <typename T>
Stack<T>::~Stack()
{
    clear();
}

template <typename T>
Stack<T>::Stack(const Stack<T>& other)
{
    if (other.size_ > 0)
    {
        max_size_ = other.max_size_;
        size_ = 0;
        header_ = tail_ = nullptr;
        LinkNode* p = other.header_;
        while (p != nullptr)
        {
            LinkNode* node = new LinkNode;
            node->elem = p->elem;
            node->pNext = nullptr;
            if (size_ == 0)
            {
                header_ = tail_ = node;
            }
            else
            {
                tail_->pNext = node;
                tail_ = node;
            }
            ++size_;
            p = p->pNext;
        }
    }
}

template <typename T>
Stack<T>& Stack<T>::operator = (const Stack<T>& other)
{
    if (this != &other)
    {
        clear();
        max_size_ = other.max_size_;
        size_ = 0;
        header_ = tail_ = nullptr;
        LinkNode* p = other.header_;
        while (p != nullptr)
        {
            LinkNode* node = new LinkNode;
            node->elem = p->elem;
            node->pNext = nullptr;
            if (size_ == 0)
            {
                header_ = tail_ = node;
            }
            else
            {
                tail_->pNext = node;
                tail_ = node;
            }
            ++size_;
            p = p->pNext;
        }
    }
    return *this;
}

template <typename T>
void Stack<T>::push(const T& elem)
{
    assert(size_<max_size_);
    LinkNode* node = new LinkNode;
    node->elem = elem;
    node->pNext = nullptr;
    if (size_ == 0)
    {
        header_ = tail_ = node;
    }
    else
    {
        node->pNext = header_;
        header_ = node;
    }
    ++size_;
}

template <typename T>
T Stack<T>::pop()
{
    assert(size_>0);
    T elem = header_->elem;
    header_ = header_->pNext;
    --size_;
    if (size_ == 0)
    {
        header_ = tail_ = nullptr;
    }
    return elem;
}

template <typename T>
bool Stack<T>::empty()
{
    return size_==0;
}

template <typename T>
void Stack<T>::clear()
{
    if (size_ > 0)
    {
        LinkNode* p = nullptr;
        while (header_ != nullptr)
        {
            p = header_->pNext;
            delete header_;
            header_ = p;
        }
        header_ = tail_ = nullptr;
        size_ = 0;
    }
}

template <typename T>
bool Stack<T>::isFull()
{
    return size_ == max_size_;
}

template <typename T>
size_t Stack<T>::size()
{
    return size_;
}

template <typename T>
void Stack<T>::show()
{
    if (size_ > 0)
    {
        LinkNode* p = header_;
        while (p != nullptr)
        {
#ifdef _DEBUG
            std::cout << p->elem << " ";
#endif
            p = p->pNext;
        }
#ifdef _DEBUG
        std::cout << std::endl;
#endif
    }
}

#endif

main.cpp

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

void TestStack()
{
    Stack<int> numberQueue;
    for (int i = 0; i < 100; i++)
    {
        numberQueue.push(i);
    }
    if (!numberQueue.empty())
    {
        cout << "numberQueue当前元素个数 : " << numberQueue.size() << endl;
    }
    Stack<int> other(numberQueue);

    numberQueue.pop();
    numberQueue.pop();
    numberQueue.pop();
    numberQueue.pop();

    numberQueue.show();

    other = numberQueue;
    other.show();
}

int main()
{
    TestStack();
    return 0;
}

makefile

#sample makefile
CC := g++
DEFS := -D _DEBUG
CXXFLAGS := -g -Wall -std=c++11
CXXFLAGS += $(DEFS)
SRCS := $(wildcard ./*.cpp)
OBJS := $(patsubst %.cpp, %.o, $(SRCS))#替换的时候是%符号，不是*
LDFLAGS := -lpthread
EXE=main.out
all:$(OBJS)
    $(CC) $(CXXFLAGS) $(OBJS) -o $(EXE) $(LDFLAGS)
    @echo '------OK!------'
#%.o:%.c
#   $(CC) -MM $(CXXFLAGS) -c $< -o $@

.PHONY:clean
clean:
    -rm -f $(OBJS)
    -rm -f $(EXE)

结果