8.stack

代码位置：https://github.com/liangleilei123/My_STL/tree/main/Code/include

概述

stack 所有元素的进出都必须符合 “先进后出”的条件，只有stack顶端的元素，才有机会被外界取用。stack 不提供走访功能，也不提供迭代器。

模版函数

friend bool operator==<>(const stack &, const stack &);

在这段程序中，<> 的作用是告诉编译器，operator== 是一个模板函数，其模板参数类型将在函数定义中指定。具体来说，operator== 是 stack 类的友元函数，用于比较两个 stack 对象是否相等。

因为 operator== 是一个模板函数，所以在声明中需要使用 <> 语法来告诉编译器这一点。具体来说，operator== 的声明应该是这样的：

template<class T, class Sequence>
class stack {
    friend bool operator==<>(const stack<T, Sequence> &, const stack<T, Sequence> &);
};

在这个声明中，operator== 接受两个 const 引用参数，它们都是 stack<T, Sequence> 类型的对象。而模板参数 T 和 Sequence 则是在类模板 stack 的定义中声明的。

友元函数

友元函数（friend function）是一种特殊的函数，它可以访问类的私有成员和保护成员。友元函数并不是类的成员函数，它是在类的外部定义的普通函数，但可以通过类的友元机制访问类的非公有成员。

友元函数可以被声明为类的友元函数，也可以被声明为类模板的友元函数。在类定义中，可以使用 friend 关键字将函数声明为友元函数。例如：

class MyClass {
public:
    // 公有成员函数
    void publicFunction();

    // 声明友元函数
    friend void friendFunction(MyClass& obj);
};

在上面的示例中，friendFunction 被声明为 MyClass 的友元函数。这意味着 friendFunction 可以访问 MyClass 的私有成员和保护成员，即使它不是 MyClass 的成员函数。

需要注意的是，友元函数不是类的成员函数，因此它不能直接访问类的成员变量和成员函数。它可以通过类的对象或指针作为参数来访问类的非公有成员。例如，在上面的示例中，friendFunction 可以通过传入 MyClass 类型的对象来访问该类的非公有成员：

void friendFunction(MyClass& obj) {
    obj.privateMember = 42;
}

需要注意的是，友元函数的使用可能会破坏封装性原则，因此应该谨慎使用。在使用友元函数时，应该考虑到安全性和维护性等方面的问题，保证代码的可读性、可维护性和可扩展性。

stack类的全部源码

template<class T, class Sequence = deque<T>>
class stack {
    friend bool operator==(const stack &, const stack &);

    friend bool operator<(const stack &, const stack &);

public:
    typedef typename Sequence::value_type value_type;
    typedef typename Sequence::size_type size_type;
    typedef typename Sequence::reference reference;
    typedef typename Sequence::const_reference const_reference;
protected:
    Sequence c; //底层容器
public:
    //以下完全利用Sequence c的操作，完成stack的操作
    bool empty() const { return c.empty(); }

    size_type size() const { return c.size(); }

    reference top() { return c.back(); }

    const_reference top() const { return c.back(); }

    //stack()是后进先出
    void push(const value_type &x) { c.push_back(x); }

    void pop() { c.pop_back(); }
};


template<class T, class Sequence>
bool operator==(const stack<T, Sequence> &x, const stack<T, Sequence> &y) {
    x.c == y.c;
}

template<class T, class Sequence>
bool operator<(const stack<T, Sequence> &x, const stack<T, Sequence> &y) {
    return x.c < y.c;
}

stack的底层可以用deque实现也可以用list实现。stack的成员函数都是调用底层容器的相应函数实现的。

//stack_POD_test.cpp
#include "my_list.h"
#include "my_stack.h"
#include "iostream"

template<class T = int>
void print_value(T x) {
    std::cout << x << std::endl;
}

int main() {
    //mystl::stack<int, mystl::list<int>> dstack;       //使用list为底层容器
    mystl::stack<int> dstack;                           //默认使用deque为底层容器
    dstack.push(1);
    dstack.push(3);
    dstack.push(5);
    dstack.push(7);

    print_value(dstack.size());         //4
    print_value(dstack.top());          //7

    dstack.pop();
    print_value(dstack.top());          //5
    dstack.pop();
    print_value(dstack.top());          //3
    dstack.pop();
    print_value(dstack.top());          //1
    print_value(dstack.size());         //1

}