浅入浅出理解栈

#include <iostream>
using namespace std;
const int Size = 5;
class Stack;
class Item
{
public:
    //********found********
    Item(const int& val) :item(val){}
        //构造函数 对item进行初始化
private:
    int item;
    Item* next;
    friend class Stack;
};
class Stack
{
public:
    Stack() :top(NULL) {}
    ~Stack();
    int Pop();
    void Push(const int&);
private:
    Item* top;
};
Stack::~Stack()
{
    Item* p = top, * q;
    while (p != NULL)
    {
        q = p->next;
        //********found********
        delete p;
        //释放p所指向的结点
        p = q;
    }
}
int Stack::Pop()
{
    Item* temp;
    int ret;
    //********found********
    temp=top;
    //使temp指向栈顶结点
    ret = top->item;
    top = top->next;
    delete temp;
    return ret;
}
void Stack::Push(const int& val)
{
    Item* temp = new Item(val);
    //********found********
    temp->next = top;
    //使新结点的next指针指向栈顶数据
    top = temp;
}
int main()
{
    Stack s;
    for (int i = 1; i < Size; i++)
        s.Push(i);
    cout << "The element of stack are: ";
    for (int i = 1; i < Size; i++)
        cout << s.Pop() << '\t';
    return 0;
}

这段代码实现了一个栈（Stack）数据结构，其中包括两个类：Item 和 Stack。

类 Item

Item 类表示栈中的元素，它具有一个整型数据成员 item 和一个指向下一个元素的指针 next。这个类包含一个构造函数，用于初始化 item 成员。

class Item
{
public:
    Item(const int& val) : item(val) {} // 构造函数，初始化 item 成员
private:
    int item; // 栈元素
    Item* next; // 指向下一个元素的指针
    friend class Stack; // 声明 Stack 类为友元类
};

类 Stack

Stack 类表示一个栈数据结构，包含一个指向栈顶元素的指针 top。它提供了三个公共方法：Push（入栈）、Pop（出栈）和析构函数。

class Stack
{
public:
    Stack() : top(NULL) {} // 默认构造函数，初始化 top 为 NULL
    ~Stack(); // 析构函数，用于释放栈内存
    int Pop(); // 出栈操作，返回出栈的元素值
    void Push(const int&); // 入栈操作，接受一个整型参数作为入栈元素
private:
    Item* top; // 指向栈顶元素的指针
};

析构函数 ~Stack

析构函数的作用是在对象销毁时释放动态分配的内存。在这个析构函数中，它通过循环遍历栈中的每个元素，并释放它们所占用的内存空间。

Stack::~Stack()
{
    Item* p = top, * q; // 定义指针 p 和 q，初始化为 top
    while (p != NULL)
    {
        q = p->next; // 记录下一个元素的指针
        delete p; // 释放当前元素所占用的内存空间
        p = q; // 移动指针到下一个元素
    }
}

出栈操作 Pop

出栈操作从栈顶移除一个元素，并返回其值。在这个方法中，首先保存栈顶元素的指针，然后返回栈顶元素的值，并将栈顶指针指向下一个元素，最后释放保存的栈顶元素的内存空间。

int Stack::Pop()
{
    Item* temp; // 定义临时指针
    int ret; // 定义返回值
    temp = top; // 保存栈顶指针
    ret = top->item; // 获取栈顶元素的值
    top = top->next; // 移动栈顶指针到下一个元素
    delete temp; // 释放保存的栈顶元素的内存空间
    return ret; // 返回栈顶元素的值
}

入栈操作 Push

入栈操作将一个新元素放入栈顶。在这个方法中，首先创建一个新的 Item 对象，然后将其 next 指针指向当前的栈顶元素，最后将栈顶指针指向新元素。

void Stack::Push(const int& val)
{
    Item* temp = new Item(val); // 创建新的 Item 对象，传入参数 val
    temp->next = top; // 将新元素的 next 指针指向当前栈顶元素
    top = temp; // 将栈顶指针指向新元素
}

主函数

在主函数中，创建了一个 Stack 对象 s，然后通过循环将数字 1 到 4 入栈，接着通过循环将栈中的元素依次出栈并输出。

这段代码实现了栈数据结构的基本操作，包括入栈、出栈和内存管理。