pfuc5ij8g
/
MyTinySTL
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

对stack.h做注释

Browse Source
main
Shiina_cd 8 months ago
parent 01c71207be
commit 6813dc2016
1 changed files with 186 additions and 141 deletions
Show Stats Download Patch File Download Diff File

133
MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/stack.h
Unescape View File

@ -1,127 +1,135 @@
#ifndef MYTINYSTL_STACK_H_ #ifndef MYTINYSTL_STACK_H_ // 预处理指令，防止头文件被重复包含
#define MYTINYSTL_STACK_H_ #define MYTINYSTL_STACK_H_
//这是个头文件
// 这个头文件包含了一个模板类 stack // 这个头文件包含了一个模板类 stack
// stack : 栈 // stack : 栈
#include "deque.h" #include "deque.h" // 包含 deque 类的头文件
namespace mystl namespace mystl // 命名空间 mystl，用于封装 mystl 库的组件
{ {
// 模板类 stack // 模板类 stack
// 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器 // 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器
template <class T, class Container = mystl::deque<T>> template <class T, class Container = mystl::deque<T>>
class stack class stack
{ {
public: public:
typedef Container container_type; typedef Container container_type; // 使用底层容器的型别
// 使用底层容器的型别 typedef typename Container::value_type value_type; // 值类型
typedef typename Container::value_type value_type; typedef typename Container::size_type size_type; // 大小类型
typedef typename Container::size_type size_type; typedef typename Container::reference reference; // 引用类型
typedef typename Container::reference reference; typedef typename Container::const_reference const_reference; // 常量引用类型
typedef typename Container::const_reference const_reference;
static_assert(std::is_same<T, value_type>::value, // 静态断言，确保 T 和 value_type 是相同的类型
static_assert(std::is_same<T, value_type>::value,
"the value_type of Container should be same with T"); "the value_type of Container should be same with T");
private: private:
container_type c_; // 用底层容器表现 stack container_type c_; // 用底层容器表现 stack
public: public:
// 构造、复制、移动函数 // 构造、复制、移动函数
stack() = default; stack() = default; // 默认构造函数
explicit stack(size_type n) explicit stack(size_type n) // 构造函数，初始化指定数量的元素
:c_(n) :c_(n)
{ {
} }
stack(size_type n, const value_type& value) stack(size_type n, const value_type& value) // 构造函数，初始化指定数量的相同元素
:c_(n, value) :c_(n, value)
{ {
} }
template <class IIter> template <class IIter>
stack(IIter first, IIter last) stack(IIter first, IIter last) // 构造函数，使用迭代器范围初始化
: c_(first, last) : c_(first, last)
{ {
} }
stack(std::initializer_list<T> ilist) stack(std::initializer_list<T> ilist) // 构造函数，使用初始化列表初始化
:c_(ilist.begin(), ilist.end()) :c_(ilist.begin(), ilist.end())
{ {
} }
stack(const Container& c) stack(const Container& c) // 构造函数，使用底层容器初始化
:c_(c) :c_(c)
{ {
} }
stack(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value) stack(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value) // 移动构造函数
:c_(mystl::move(c)) :c_(mystl::move(c))
{ {
} }
stack(const stack& rhs) stack(const stack& rhs) // 复制构造函数
:c_(rhs.c_) :c_(rhs.c_)
{ {
} }
stack(stack&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::value) stack(stack&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::value) // 移动构造函数
:c_(mystl::move(rhs.c_)) :c_(mystl::move(rhs.c_))
{ {
} }
stack& operator=(const stack& rhs) stack& operator=(const stack& rhs) // 复制赋值运算符
{ {
c_ = rhs.c_; c_ = rhs.c_;
return *this; return *this;
} }
stack& operator=(stack&& rhs) noexcept(std::is_nothrow_move_assignable<Container>::value) stack& operator=(stack&& rhs) noexcept(std::is_nothrow_move_assignable<Container>::value) // 移动赋值运算符
{ {
c_ = mystl::move(rhs.c_); c_ = mystl::move(rhs.c_);
return *this; return *this;
} }
stack& operator=(std::initializer_list<T> ilist) stack& operator=(std::initializer_list<T> ilist) // 初始化列表赋值运算符
{ {
c_ = ilist; c_ = ilist;
return *this; return *this;
} }
~stack() = default; ~stack() = default; // 默认析构函数
// 访问元素相关操作 // 访问元素相关操作
reference top() { return c_.back(); } reference top() { return c_.back(); } // 返回栈顶元素的引用
const_reference top() const { return c_.back(); } const_reference top() const { return c_.back(); } // 返回栈顶元素的常量引用
// 容量相关操作 // 容量相关操作
bool empty() const noexcept { return c_.empty(); } bool empty() const noexcept { return c_.empty(); } // 检查栈是否为空
size_type size() const noexcept { return c_.size(); } size_type size() const noexcept { return c_.size(); } // 返回栈的大小
// 修改容器相关操作 // 修改容器相关操作
template <class... Args> template <class... Args>
void emplace(Args&& ...args) void emplace(Args&& ...args) // 原地构造并添加元素到栈顶
{ c_.emplace_back(mystl::forward<Args>(args)...); } {
c_.emplace_back(mystl::forward<Args>(args)...);
}
void push(const value_type& value) void push(const value_type& value) // 将元素添加到栈顶
{ c_.push_back(value); } {
void push(value_type&& value) c_.push_back(value);
{ c_.push_back(mystl::move(value)); } }
void push(value_type&& value) // 将移动构造的元素添加到栈顶
{
c_.push_back(mystl::move(value));
}
void pop() void pop() // 移除栈顶元素
{ c_.pop_back(); } {
c_.pop_back();
}
void clear() void clear() // 清空栈
{ {
while (!empty()) while (!empty())
pop(); pop();
} }
void swap(stack& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_))) void swap(stack& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_))) // 交换两个栈的内容
{ mystl::swap(c_, rhs.c_); } {
mystl::swap(c_, rhs.c_);
}
public: public:
friend bool operator==(const stack& lhs, const stack& rhs) { return lhs.c_ == rhs.c_; } friend bool operator==(const stack& lhs, const stack& rhs) { return lhs.c_ == rhs.c_; } // 比较运算符，检查两个栈是否相等
friend bool operator< (const stack& lhs, const stack& rhs) { return lhs.c_ < rhs.c_; } friend bool operator< (const stack& lhs, const stack& rhs) { return lhs.c_ < rhs.c_; } // 比较运算符，检查一个栈是否小于另一个栈
}; };
// 重载比较操作符 // 重载比较操作符
@ -170,4 +178,41 @@ void swap(stack<T, Container>& lhs, stack<T, Container>& rhs) noexcept(noexcept(
} // namespace mystl } // namespace mystl
#endif // !MYTINYSTL_STACK_H_ #endif // !MYTINYSTL_STACK_H_
// 比较运算符，检查两个栈是否不相等
template <class T, class Container>
bool operator!=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return !(lhs == rhs);
}
// 比较运算符，检查一个栈是否大于另一个栈
template <class T, class Container>
bool operator>(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return rhs < lhs; // 如果rhs小于lhs，则lhs大于rhs
}
// 比较运算符，检查一个栈是否小于或等于另一个栈
template <class T, class Container>
bool operator<=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return !(rhs < lhs); // 如果rhs不小于lhs，则lhs小于或等于rhs
}
// 比较运算符，检查一个栈是否大于或等于另一个栈
template <class T, class Container>
bool operator>=(const stack<T, Container>& lhs, const stack<T, Container>& rhs)
{
return !(lhs < rhs); // 如果lhs不小于rhs，则lhs大于或等于rhs
}
// 重载 mystl 的 swap 函数，用于交换两个 stack 对象的内容
// 这个函数是友元函数，因为它需要访问 stack 的私有成员
template <class T, class Container>
void swap(stack<T, Container>& lhs, stack<T, Container>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs); // 调用 stack 类的 swap 方法
}
} // namespace mystl 结束命名空间
#endif // !MYTINYSTL_STACK_H_ 结束头文件保护宏定义
Write Preview
Loading…
Cancel
Save