代码位置: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
}