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

对queue.h做注释

Browse Source
main
Shiina_cd 8 months ago
parent e5fdcccf29
commit 4d5cdc804d
1 changed files with 356 additions and 349 deletions
Show Stats Download Patch File Download Diff File

339
MyTinySTL/src/MyTinySTL-master/MyTinySTL-master/MyTinySTL/queue.h
Unescape View File

@ -1,274 +1,287 @@
#ifndef MYTINYSTL_QUEUE_H_ #ifndef MYTINYSTL_QUEUE_H_ // 预处理指令，防止头文件被重复包含
#define MYTINYSTL_QUEUE_H_ #define MYTINYSTL_QUEUE_H_
// 这个头文件包含了两个模板类 queue 和 priority_queue // 这个头文件包含了两个模板类 queue 和 priority_queue
// queue : 队列 // queue : 队列
// priority_queue : 优先队列 // priority_queue : 优先队列
#include "deque.h" #include "deque.h" // 包含 deque 类的头文件
#include "vector.h" #include "vector.h" // 包含 vector 类的头文件
#include "functional.h" #include "functional.h" // 包含 functional 头文件，提供比较函数等
#include "heap_algo.h" #include "heap_algo.h" // 包含堆算法的头文件
namespace mystl namespace mystl // 命名空间 mystl，用于封装 mystl 库的组件
{ {
// 模板类 queue // 模板类 queue
// 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器 // 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器
template <class T, class Container = mystl::deque<T>> template <class T, class Container = mystl::deque<T>>
class queue class queue
{ {
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_; // 用底层容器表现 queue container_type c_; // 用底层容器表现 queue
public: public:
// 构造、复制、移动函数 // 构造、复制、移动函数
queue() = default; // 默认构造函数
queue() = default; explicit queue(size_type n) // 构造函数，初始化指定数量的元素
explicit queue(size_type n)
:c_(n) :c_(n)
{ {
} }
queue(size_type n, const value_type& value) queue(size_type n, const value_type& value) // 构造函数，初始化指定数量的相同元素
:c_(n, value) :c_(n, value)
{ {
} }
template <class IIter> template <class IIter>
queue(IIter first, IIter last) queue(IIter first, IIter last) // 构造函数，使用迭代器范围初始化
:c_(first, last) : c_(first, last)
{ {
} }
queue(std::initializer_list<T> ilist) queue(std::initializer_list<T> ilist) // 构造函数，使用初始化列表初始化
:c_(ilist.begin(), ilist.end()) :c_(ilist.begin(), ilist.end())
{ {
} }
queue(const Container& c) queue(const Container& c) // 构造函数，使用底层容器初始化
:c_(c) :c_(c)
{ {
} }
queue(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value) queue(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value) // 移动构造函数
:c_(mystl::move(c)) :c_(mystl::move(c))
{ {
} }
queue(const queue& rhs) queue(const queue& rhs) // 复制构造函数
:c_(rhs.c_) :c_(rhs.c_)
{ {
} }
queue(queue&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::value) queue(queue&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::value) // 移动构造函数
:c_(mystl::move(rhs.c_)) :c_(mystl::move(rhs.c_))
{ {
} }
queue& operator=(const queue& rhs) queue& operator=(const queue& rhs) // 复制赋值运算符
{ {
c_ = rhs.c_; c_ = rhs.c_;
return *this; return *this;
} }
queue& operator=(queue&& rhs) noexcept(std::is_nothrow_move_assignable<Container>::value) queue& operator=(queue&& rhs) noexcept(std::is_nothrow_move_assignable<Container>::value) // 移动赋值运算符
{ {
c_ = mystl::move(rhs.c_); c_ = mystl::move(rhs.c_);
return *this; return *this;
} }
queue& operator=(std::initializer_list<T> ilist) queue& operator=(std::initializer_list<T> ilist) // 初始化列表赋值运算符
{ {
c_ = ilist; c_ = ilist;
return *this; return *this;
} }
~queue() = default; ~queue() = default; // 默认析构函数
// 访问元素相关操作 // 访问元素相关操作
reference front() { return c_.front(); } reference front() { return c_.front(); } // 返回队头元素的引用
const_reference front() const { return c_.front(); } const_reference front() const { return c_.front(); } // 返回队头元素的常量引用
reference back() { return c_.back(); } reference back() { return c_.back(); } // 返回队尾元素的引用
const_reference back() const { return c_.back(); } const_reference back() 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_.emplace_back(mystl::move(value)); } }
void push(value_type&& value) // 将移动构造的元素添加到队尾
{
c_.emplace_back(mystl::move(value));
}
void pop() void pop() // 移除队头元素
{ c_.pop_front(); } {
c_.pop_front();
}
void clear() void clear() // 清空队列
{ {
while (!empty()) while (!empty())
pop(); pop();
} }
void swap(queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_))) void swap(queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_))) // 交换两个队列的内容
{ mystl::swap(c_, rhs.c_); } {
mystl::swap(c_, rhs.c_);
}
public: public:
friend bool operator==(const queue& lhs, const queue& rhs) { return lhs.c_ == rhs.c_; } friend bool operator==(const queue& lhs, const queue& rhs) // 比较运算符，检查两个队列是否相等
friend bool operator< (const queue& lhs, const queue& rhs) { return lhs.c_ < rhs.c_; } {
}; return lhs.c_ == rhs.c_;
}
friend bool operator< (const queue& lhs, const queue& rhs) // 比较运算符，检查一个队列是否小于另一个队列
{
return lhs.c_ < rhs.c_;
}
};
// 重载比较操作符 // 重载比较操作符
template <class T, class Container> template <class T, class Container>
bool operator==(const queue<T, Container>& lhs, const queue<T, Container>& rhs) bool operator==(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ {
return lhs == rhs; return lhs == rhs;
} }
template <class T, class Container> template <class T, class Container>
bool operator!=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) bool operator!=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ {
return !(lhs == rhs); return !(lhs == rhs);
} }
template <class T, class Container> template <class T, class Container>
bool operator<(const queue<T, Container>& lhs, const queue<T, Container>& rhs) bool operator<(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ {
return lhs < rhs; return lhs < rhs;
} }
template <class T, class Container> template <class T, class Container>
bool operator>(const queue<T, Container>& lhs, const queue<T, Container>& rhs) bool operator>(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ {
return rhs < lhs; return rhs < lhs;
} }
template <class T, class Container> template <class T, class Container>
bool operator<=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) bool operator<=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ {
return !(rhs < lhs); return !(rhs < lhs);
} }
template <class T, class Container> template <class T, class Container>
bool operator>=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) bool operator>=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ {
return !(lhs < rhs); return !(lhs < rhs);
} }
// 重载 mystl 的 swap // 重载 mystl 的 swap
template <class T, class Container> template <class T, class Container>
void swap(queue<T, Container>& lhs, queue<T, Container>& rhs) noexcept(noexcept(lhs.swap(rhs))) void swap(queue<T, Container>& lhs, queue<T, Container>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{ {
lhs.swap(rhs); lhs.swap(rhs);
} }
/*****************************************************************************************/
/*****************************************************************************************/
// 模板类 priority_queue // 模板类 priority_queue
// 参数一代表数据类型，参数二代表容器类型，缺省使用 mystl::vector 作为底层容器 // 参数一代表数据类型，参数二代表容器类型，缺省使用 mystl::vector 作为底层容器
// 参数三代表比较权值的方式，缺省使用 mystl::less 作为比较方式 // 参数三代表比较权值的方式，缺省使用 mystl::less 作为比较方式
template <class T, class Container = mystl::vector<T>, template <class T, class Container = mystl::vector<T>,
class Compare = mystl::less<typename Container::value_type>> class Compare = mystl::less<typename Container::value_type>>
class priority_queue class priority_queue
{ {
public: public:
typedef Container container_type; typedef Container container_type; // 使用底层容器的型别
typedef Compare value_compare; typedef Compare value_compare; // 用于比较的函数对象类型
// 使用底层容器的型别 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_; // 用底层容器来表现 priority_queue container_type c_; // 用底层容器来表现 priority_queue
value_compare comp_; // 权值比较的标准 value_compare comp_; // 权值比较的标准
public: public:
// 构造、复制、移动函数 // 构造、复制、移动函数
priority_queue() = default; priority_queue() = default; // 默认构造函数
priority_queue(const Compare& c) priority_queue(const Compare& comp) // 构造函数，指定比较函数
:c_(), comp_(c) :c_(), comp_(comp)
{ {
} }
explicit priority_queue(size_type n) explicit priority_queue(size_type n) // 构造函数，初始化指定数量的元素
:c_(n) :c_(n)
{ {
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_); // 构建为堆
} }
priority_queue(size_type n, const value_type& value) priority_queue(size_type n, const value_type& value) // 构造函数，初始化指定数量的相同元素
:c_(n, value) :c_(n, value)
{ {
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_); // 构建为堆
} }
template <class IIter> template <class IIter>
priority_queue(IIter first, IIter last) priority_queue(IIter first, IIter last) // 构造函数，使用迭代器范围初始化
:c_(first, last) : c_(first, last)
{ {
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_); // 构建为堆
} }
priority_queue(std::initializer_list<T> ilist) priority_queue(std::initializer_list<T> ilist) // 构造函数，使用初始化列表初始化
:c_(ilist) :c_(ilist)
{ {
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_); // 构建为堆
} }
priority_queue(const Container& s) priority_queue(const Container& s) // 构造函数，使用底层容器初始化
:c_(s) :c_(s)
{ {
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_); // 构建为堆
} }
priority_queue(Container&& s) priority_queue(Container&& s) // 移动构造函数
:c_(mystl::move(s)) :c_(mystl::move(s))
{ {
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_); // 构建为堆
} }
priority_queue(const priority_queue& rhs) priority_queue(const priority_queue& rhs) // 复制构造函数
:c_(rhs.c_), comp_(rhs.comp_) :c_(rhs.c_), comp_(rhs.comp_)
{ {
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_); // 构建为堆
} }
priority_queue(priority_queue&& rhs) priority_queue(priority_queue&& rhs) // 移动构造函数
:c_(mystl::move(rhs.c_)), comp_(rhs.comp_) :c_(mystl::move(rhs.c_)), comp_(rhs.comp_)
{ {
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_); // 构建为堆
} }
priority_queue& operator=(const priority_queue& rhs) priority_queue& operator=(const priority_queue& rhs) // 复制赋值运算符
{ {
c_ = rhs.c_; c_ = rhs.c_;
comp_ = rhs.comp_; comp_ = rhs.comp_;
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this; return *this;
} }
priority_queue& operator=(priority_queue&& rhs) priority_queue& operator=(priority_queue&& rhs) // 移动赋值运算符
{ {
c_ = mystl::move(rhs.c_); c_ = mystl::move(rhs.c_);
comp_ = rhs.comp_; comp_ = rhs.comp_;
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this; return *this;
} }
priority_queue& operator=(std::initializer_list<T> ilist) priority_queue& operator=(std::initializer_list<T> ilist) // 初始化列表赋值运算符
{ {
c_ = ilist; c_ = ilist;
comp_ = value_compare(); comp_ = value_compare();
@ -276,43 +289,41 @@ public:
return *this; return *this;
} }
~priority_queue() = default; ~priority_queue() = default; // 默认析构函数
public:
// 访问元素相关操作 // 访问元素相关操作
const_reference top() const { return c_.front(); } const_reference top() const { return c_.front(); } // 返回堆顶元素的常量引用
// 容量相关操作 // 容量相关操作
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)...);
mystl::push_heap(c_.begin(), c_.end(), comp_); mystl::push_heap(c_.begin(), c_.end(), comp_); // 维护堆的性质
} }
void push(const value_type& value) void push(const value_type& value) // 将元素添加到优先队列
{ {
c_.push_back(value); c_.push_back(value);
mystl::push_heap(c_.begin(), c_.end(), comp_); mystl::push_heap(c_.begin(), c_.end(), comp_); // 维护堆的性质
} }
void push(value_type&& value) void push(value_type&& value) // 将移动构造的元素添加到优先队列
{ {
c_.push_back(mystl::move(value)); c_.push_back(mystl::move(value));
mystl::push_heap(c_.begin(), c_.end(), comp_); mystl::push_heap(c_.begin(), c_.end(), comp_); // 维护堆的性质
} }
void pop() void pop() // 移除堆顶元素
{ {
mystl::pop_heap(c_.begin(), c_.end(), comp_); mystl::pop_heap(c_.begin(), c_.end(), comp_); // 维护堆的性质
c_.pop_back(); c_.pop_back();
} }
void clear() void clear() // 清空优先队列
{ {
while (!empty()) while (!empty())
pop(); pop();
@ -322,43 +333,39 @@ public:
noexcept(mystl::swap(comp_, rhs.comp_))) noexcept(mystl::swap(comp_, rhs.comp_)))
{ {
mystl::swap(c_, rhs.c_); mystl::swap(c_, rhs.c_);
mystl::swap(comp_, rhs.comp_); mystl::swap(comp_, rhs.comp_); // 交换比较函数对象
} }
public: public:
friend bool operator==(const priority_queue& lhs, const priority_queue& rhs) friend bool operator==(const priority_queue& lhs, const priority_queue& rhs) // 比较运算符，检查两个优先队列是否相等
{ {
return lhs.c_ == rhs.c_; return lhs.c_ == rhs.c_;
} }
friend bool operator!=(const priority_queue& lhs, const priority_queue& rhs) friend bool operator!=(const priority_queue& lhs, const priority_queue& rhs) // 比较运算符，检查两个优先队列是否不相等
{ {
return lhs.c_ != rhs.c_; return lhs.c_ != rhs.c_;
} }
}; };
// 重载比较操作符 // 重载比较操作符
template <class T, class Container, class Compare> template <class T, class Container, class Compare>
bool operator==(priority_queue<T, Container, Compare>& lhs, bool operator==(priority_queue<T, Container, Compare>& lhs, priority_queue<T, Container, Compare>& rhs)
priority_queue<T, Container, Compare>& rhs) {
{
return lhs == rhs; return lhs == rhs;
} }
template <class T, class Container, class Compare> template <class T, class Container, class Compare>
bool operator!=(priority_queue<T, Container, Compare>& lhs, bool operator!=(priority_queue<T, Container, Compare>& lhs, priority_queue<T, Container, Compare>& rhs)
priority_queue<T, Container, Compare>& rhs) {
{
return lhs != rhs; return lhs != rhs;
} }
// 重载 mystl 的 swap // 重载 mystl 的 swap
template <class T, class Container, class Compare> template <class T, class Container, class Compare>
void swap(priority_queue<T, Container, Compare>& lhs, void swap(priority_queue<T, Container, Compare>& lhs, priority_queue<T, Container, Compare>& rhs) noexcept(noexcept(lhs.swap(rhs)))
priority_queue<T, Container, Compare>& rhs) noexcept(noexcept(lhs.swap(rhs))) {
{
lhs.swap(rhs); lhs.swap(rhs);
} }
} // namespace mystl } // namespace mystl
#endif // !MYTINYSTL_QUEUE_H_ #endif // !MYTINYSTL_QUEUE_H_

Write Preview
Loading…
Cancel
Save