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

上传文件至 'src/MyTinySTL-master/MyTinySTL'

Browse Source 
我是赵澜博
main
赵澜博 7 months ago
parent 42950ef3ff
commit deeabedd43
5 changed files with 3014 additions and 3014 deletions
Show Stats Download Patch File Download Diff File

1098
src/MyTinySTL-master/MyTinySTL/map.h
View File

File diff suppressed because it is too large Load Diff

416
src/MyTinySTL-master/MyTinySTL/memory.h
Unescape View File

@ -1,208 +1,208 @@
#ifndef MYTINYSTL_MEMORY_H_ #ifndef MYTINYSTL_MEMORY_H_ //
#define MYTINYSTL_MEMORY_H_ #define MYTINYSTL_MEMORY_H_
// 这个头文件负责更高级的动态内存管理 // 这个头文件负责更高级的动态内存管理 //
// 包含一些基本函数、空间配置器、未初始化的储存空间管理，以及一个模板类 auto_ptr // 包含一些基本函数、空间配置器、未初始化的储存空间管理，以及一个模板类 auto_ptr
#include <cstddef> #include <cstddef>
#include <cstdlib> #include <cstdlib>
#include <climits> #include <climits>
#include "algobase.h" #include "algobase.h"
#include "allocator.h" #include "allocator.h"
#include "construct.h" #include "construct.h" //
#include "uninitialized.h" #include "uninitialized.h"
//
namespace mystl namespace mystl
{ {
// 获取对象地址 // 获取对象地址
template <class Tp> template <class Tp>
constexpr Tp* address_of(Tp& value) noexcept constexpr Tp* address_of(Tp& value) noexcept //
{ {
return &value; return &value;
} }
//
// 获取 / 释放 临时缓冲区 // 获取 / 释放 临时缓冲区 //
//
template <class T> template <class T>
pair<T*, ptrdiff_t> get_buffer_helper(ptrdiff_t len, T*) pair<T*, ptrdiff_t> get_buffer_helper(ptrdiff_t len, T*)
{ {
if (len > static_cast<ptrdiff_t>(INT_MAX / sizeof(T))) if (len > static_cast<ptrdiff_t>(INT_MAX / sizeof(T))) //
len = INT_MAX / sizeof(T); len = INT_MAX / sizeof(T);
while (len > 0) while (len > 0)
{ {
T* tmp = static_cast<T*>(malloc(static_cast<size_t>(len) * sizeof(T))); T* tmp = static_cast<T*>(malloc(static_cast<size_t>(len) * sizeof(T)));
if (tmp) if (tmp)
return pair<T*, ptrdiff_t>(tmp, len); return pair<T*, ptrdiff_t>(tmp, len); //
len /= 2; // 申请失败时减少 len 的大小 len /= 2; // 申请失败时减少 len 的大小
} }
return pair<T*, ptrdiff_t>(nullptr, 0); return pair<T*, ptrdiff_t>(nullptr, 0); //
} } //
template <class T> template <class T>
pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t len) pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t len)
{ {
return get_buffer_helper(len, static_cast<T*>(0)); return get_buffer_helper(len, static_cast<T*>(0));
} }
template <class T> template <class T> //
pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t len, T*) pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t len, T*)
{ { //
return get_buffer_helper(len, static_cast<T*>(0)); return get_buffer_helper(len, static_cast<T*>(0));
} }
template <class T> template <class T> //
void release_temporary_buffer(T* ptr) void release_temporary_buffer(T* ptr)
{ {
free(ptr); free(ptr); //
} }
// -------------------------------------------------------------------------------------- // -------------------------------------------------------------------------------------- //
// 类模板 : temporary_buffer // 类模板 : temporary_buffer
// 进行临时缓冲区的申请与释放 // 进行临时缓冲区的申请与释放
template <class ForwardIterator, class T> template <class ForwardIterator, class T> //
class temporary_buffer class temporary_buffer //
{ {
private: private:
ptrdiff_t original_len; // 缓冲区申请的大小 ptrdiff_t original_len; // 缓冲区申请的大小
ptrdiff_t len; // 缓冲区实际的大小 ptrdiff_t len; // 缓冲区实际的大小
T* buffer; // 指向缓冲区的指针 T* buffer; // 指向缓冲区的指针
public: public:
// 构造、析构函数 // 构造、析构函数 //
temporary_buffer(ForwardIterator first, ForwardIterator last); temporary_buffer(ForwardIterator first, ForwardIterator last);
//
~temporary_buffer() ~temporary_buffer() //
{ { //
mystl::destroy(buffer, buffer + len); mystl::destroy(buffer, buffer + len);
free(buffer); free(buffer);
} }
//
public: public:
ptrdiff_t size() const noexcept { return len; } ptrdiff_t size() const noexcept { return len; }
ptrdiff_t requested_size() const noexcept { return original_len; } ptrdiff_t requested_size() const noexcept { return original_len; } //
T* begin() noexcept { return buffer; } T* begin() noexcept { return buffer; }
T* end() noexcept { return buffer + len; } T* end() noexcept { return buffer + len; } //
private: private: //
void allocate_buffer(); void allocate_buffer();
void initialize_buffer(const T&, std::true_type) {} void initialize_buffer(const T&, std::true_type) {} //
void initialize_buffer(const T& value, std::false_type) void initialize_buffer(const T& value, std::false_type)
{ mystl::uninitialized_fill_n(buffer, len, value); } { mystl::uninitialized_fill_n(buffer, len, value); } //
private: private:
temporary_buffer(const temporary_buffer&); temporary_buffer(const temporary_buffer&); //
void operator=(const temporary_buffer&); void operator=(const temporary_buffer&); //
}; };
//
// 构造函数 // 构造函数
template <class ForwardIterator, class T> template <class ForwardIterator, class T>
temporary_buffer<ForwardIterator, T>:: temporary_buffer<ForwardIterator, T>::
temporary_buffer(ForwardIterator first, ForwardIterator last) temporary_buffer(ForwardIterator first, ForwardIterator last)
{ {
try try //
{ {
len = mystl::distance(first, last); len = mystl::distance(first, last);
allocate_buffer(); allocate_buffer();
if (len > 0) if (len > 0)
{ {
initialize_buffer(*first, std::is_trivially_default_constructible<T>()); initialize_buffer(*first, std::is_trivially_default_constructible<T>()); //
} }
} }
catch (...) catch (...)
{ {
free(buffer); free(buffer);
buffer = nullptr; buffer = nullptr; //
len = 0; len = 0; //
} }
} }
//
// allocate_buffer 函数 // allocate_buffer 函数
template <class ForwardIterator, class T> template <class ForwardIterator, class T>
void temporary_buffer<ForwardIterator, T>::allocate_buffer() void temporary_buffer<ForwardIterator, T>::allocate_buffer()
{ { //
original_len = len; original_len = len;
if (len > static_cast<ptrdiff_t>(INT_MAX / sizeof(T))) if (len > static_cast<ptrdiff_t>(INT_MAX / sizeof(T))) //
len = INT_MAX / sizeof(T); len = INT_MAX / sizeof(T);
while (len > 0) while (len > 0) //
{ {
buffer = static_cast<T*>(malloc(len * sizeof(T))); buffer = static_cast<T*>(malloc(len * sizeof(T))); //
if (buffer) if (buffer)
break; break; //
len /= 2; // 申请失败时减少申请空间大小 len /= 2; // 申请失败时减少申请空间大小
} } //
} } //
//
// -------------------------------------------------------------------------------------- // --------------------------------------------------------------------------------------
// 模板类: auto_ptr // 模板类: auto_ptr //
// 一个具有严格对象所有权的小型智能指针 // 一个具有严格对象所有权的小型智能指针
template <class T> template <class T> //
class auto_ptr class auto_ptr //
{ {
public: public:
typedef T elem_type; typedef T elem_type; //
//
private: private:
T* m_ptr; // 实际指针 T* m_ptr; // 实际指针
//
public: public:
// 构造、复制、析构函数 // 构造、复制、析构函数 //
explicit auto_ptr(T* p = nullptr) :m_ptr(p) {} explicit auto_ptr(T* p = nullptr) :m_ptr(p) {}
auto_ptr(auto_ptr& rhs) :m_ptr(rhs.release()) {} auto_ptr(auto_ptr& rhs) :m_ptr(rhs.release()) {} //
template <class U> template <class U>
auto_ptr(auto_ptr<U>& rhs) : m_ptr(rhs.release()) {} auto_ptr(auto_ptr<U>& rhs) : m_ptr(rhs.release()) {}
//
auto_ptr& operator=(auto_ptr& rhs) auto_ptr& operator=(auto_ptr& rhs) //
{ {
if (this != &rhs) if (this != &rhs)
{ {
delete m_ptr; delete m_ptr; //
m_ptr = rhs.release(); m_ptr = rhs.release();
} }
return *this; return *this;
} }
template <class U> template <class U> //
auto_ptr& operator=(auto_ptr<U>& rhs) auto_ptr& operator=(auto_ptr<U>& rhs) //
{ {
if (this->get() != rhs.get()) if (this->get() != rhs.get())
{ {
delete m_ptr; delete m_ptr;
m_ptr = rhs.release(); m_ptr = rhs.release(); //
} } //
return *this; return *this;
} } //
//
~auto_ptr() { delete m_ptr; } ~auto_ptr() { delete m_ptr; }
//
public: public:
// 重载 operator* 和 operator-> // 重载 operator* 和 operator->
T& operator*() const { return *m_ptr; } T& operator*() const { return *m_ptr; } //
T* operator->() const { return m_ptr; } T* operator->() const { return m_ptr; }
// 获得指针 // 获得指针 //
T* get() const { return m_ptr; } T* get() const { return m_ptr; }
// 释放指针 // 释放指针 //
T* release() T* release()
{ {
T* tmp = m_ptr; T* tmp = m_ptr;
m_ptr = nullptr; m_ptr = nullptr;
return tmp; return tmp;
} } //
// 重置指针 // 重置指针
void reset(T* p = nullptr) void reset(T* p = nullptr)
{ {
if (m_ptr != p) if (m_ptr != p)
{ { //
delete m_ptr; delete m_ptr;
m_ptr = p; m_ptr = p; //
} }
} }
}; };
//
} // namespace mystl } // namespace mystl
#endif // !MYTINYSTL_MEMORY_H_ #endif // !MYTINYSTL_MEMORY_H_ //

310
src/MyTinySTL-master/MyTinySTL/numeric.h
Unescape View File

@ -1,155 +1,155 @@
#ifndef MYTINYSTL_NUMERIC_H_ #ifndef MYTINYSTL_NUMERIC_H_ //
#define MYTINYSTL_NUMERIC_H_ #define MYTINYSTL_NUMERIC_H_
// 这个头文件包含了 mystl 的数值算法 // 这个头文件包含了 mystl 的数值算法
#include "iterator.h" #include "iterator.h"
namespace mystl namespace mystl
{ { //
/*****************************************************************************************/ /*****************************************************************************************/ //
// accumulate // accumulate
// 版本1：以初值 init 对每个元素进行累加 // 版本1：以初值 init 对每个元素进行累加 //
// 版本2：以初值 init 对每个元素进行二元操作 // 版本2：以初值 init 对每个元素进行二元操作
/*****************************************************************************************/ /*****************************************************************************************/
// 版本1 // 版本1 //
template <class InputIter, class T> template <class InputIter, class T>
T accumulate(InputIter first, InputIter last, T init) T accumulate(InputIter first, InputIter last, T init)
{ { //
for (; first != last; ++first) for (; first != last; ++first)
{ { //
init += *first; init += *first;
} }
return init; return init;
} } //
// 版本2 // 版本2
template <class InputIter, class T, class BinaryOp> template <class InputIter, class T, class BinaryOp>
T accumulate(InputIter first, InputIter last, T init, BinaryOp binary_op) T accumulate(InputIter first, InputIter last, T init, BinaryOp binary_op)
{ {
for (; first != last; ++first) for (; first != last; ++first) //
{ {
init = binary_op(init, *first); init = binary_op(init, *first);
} } //
return init; return init; //
} } //
//
/*****************************************************************************************/ /*****************************************************************************************/
// adjacent_difference // adjacent_difference
// 版本1：计算相邻元素的差值，结果保存到以 result 为起始的区间上 // 版本1：计算相邻元素的差值，结果保存到以 result 为起始的区间上 //
// 版本2：自定义相邻元素的二元操作 // 版本2：自定义相邻元素的二元操作 //
/*****************************************************************************************/ /*****************************************************************************************/
// 版本1 // 版本1 //
template <class InputIter, class OutputIter> template <class InputIter, class OutputIter>
OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result) OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result)
{ {
if (first == last) return result; if (first == last) return result;
*result = *first; // 记录第一个元素 *result = *first; // 记录第一个元素
auto value = *first; auto value = *first; //
while (++first != last) while (++first != last)
{ { //
auto tmp = *first; auto tmp = *first;
*++result = tmp - value; *++result = tmp - value; //
value = tmp; value = tmp;
} }
return ++result; return ++result;
} } //
// 版本2 // 版本2
template <class InputIter, class OutputIter, class BinaryOp> template <class InputIter, class OutputIter, class BinaryOp>
OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result, OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter result, //
BinaryOp binary_op) BinaryOp binary_op)
{ {
if (first == last) return result; if (first == last) return result; //
*result = *first; // 记录第一个元素 *result = *first; // 记录第一个元素 //
auto value = *first; auto value = *first;
while (++first != last) while (++first != last)
{ {
auto tmp = *first; auto tmp = *first;
*++result = binary_op(tmp, value); *++result = binary_op(tmp, value);
value = tmp; value = tmp;
} }
return ++result; return ++result; //
} }
/*****************************************************************************************/ /*****************************************************************************************/
// inner_product // inner_product
// 版本1：以 init 为初值，计算两个区间的内积 // 版本1：以 init 为初值，计算两个区间的内积
// 版本2：自定义 operator+ 和 operator* // 版本2：自定义 operator+ 和 operator*
/*****************************************************************************************/ /*****************************************************************************************/
// 版本1 // 版本1 //
template <class InputIter1, class InputIter2, class T> template <class InputIter1, class InputIter2, class T>
T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init) T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init) //
{ {
for (; first1 != last1; ++first1, ++first2) for (; first1 != last1; ++first1, ++first2) //
{ {
init = init + (*first1 * *first2); init = init + (*first1 * *first2);
} } //
return init; return init;
} }
// 版本2 // 版本2
template <class InputIter1, class InputIter2, class T, class BinaryOp1, class BinaryOp2> template <class InputIter1, class InputIter2, class T, class BinaryOp1, class BinaryOp2>
T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init, T inner_product(InputIter1 first1, InputIter1 last1, InputIter2 first2, T init, //
BinaryOp1 binary_op1, BinaryOp2 binary_op2) BinaryOp1 binary_op1, BinaryOp2 binary_op2)
{ {
for (; first1 != last1; ++first1, ++first2) for (; first1 != last1; ++first1, ++first2) //
{ {
init = binary_op1(init, binary_op2(*first1, *first2)); init = binary_op1(init, binary_op2(*first1, *first2)); //
} }
return init; return init;
} }
//
/*****************************************************************************************/ /*****************************************************************************************/
// iota // iota //
// 填充[first, last)，以 value 为初值开始递增 // 填充[first, last)，以 value 为初值开始递增 //
/*****************************************************************************************/ /*****************************************************************************************/
template <class ForwardIter, class T> template <class ForwardIter, class T>
void iota(ForwardIter first, ForwardIter last, T value) void iota(ForwardIter first, ForwardIter last, T value) //
{ {
while (first != last) while (first != last) //
{ {
*first++ = value; *first++ = value; //
++value; ++value;
} } //
} }
//
/*****************************************************************************************/ /*****************************************************************************************/
// partial_sum // partial_sum
// 版本1：计算局部累计求和，结果保存到以 result 为起始的区间上 // 版本1：计算局部累计求和，结果保存到以 result 为起始的区间上
// 版本2：进行局部进行自定义二元操作 // 版本2：进行局部进行自定义二元操作 //
/*****************************************************************************************/ /*****************************************************************************************/
template <class InputIter, class OutputIter> template <class InputIter, class OutputIter>
OutputIter partial_sum(InputIter first, InputIter last, OutputIter result) OutputIter partial_sum(InputIter first, InputIter last, OutputIter result) //
{ {
if (first == last) return result; if (first == last) return result;
*result = *first; // 记录第一个元素 *result = *first; // 记录第一个元素 //
auto value = *first; auto value = *first;
while (++first != last) while (++first != last) //
{ {
value = value + *first; value = value + *first; //
*++result = value; *++result = value;
} } //
return ++result; return ++result;
} } //
//
// 版本2 // 版本2 //
template <class InputIter, class OutputIter, class BinaryOp> template <class InputIter, class OutputIter, class BinaryOp>
OutputIter partial_sum(InputIter first, InputIter last, OutputIter result, OutputIter partial_sum(InputIter first, InputIter last, OutputIter result, //
BinaryOp binary_op) BinaryOp binary_op)
{ { //
if (first == last) return result; if (first == last) return result;
*result = *first; //记录第一个元素 *result = *first; //记录第一个元素
auto value = *first; auto value = *first;
while (++first != last) while (++first != last) //
{ {
value = binary_op(value, *first); value = binary_op(value, *first); //
*++result = value; *++result = value;
} }
return ++result; return ++result;
} }
} // namespace mystl } // namespace mystl
#endif // !MYTINYSTL_NUMERIC_H_ #endif // !MYTINYSTL_NUMERIC_H_ //

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

@ -1,364 +1,364 @@
#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"
#include "vector.h" #include "vector.h" //
#include "functional.h" #include "functional.h"
#include "heap_algo.h" #include "heap_algo.h"
namespace mystl namespace 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, 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); } { c_.push_back(value); } //
void push(value_type&& value) void push(value_type&& value)
{ c_.emplace_back(mystl::move(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) { return lhs.c_ == rhs.c_; }
friend bool operator< (const queue& lhs, const queue& rhs) { 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, 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& c) //
:c_(), comp_(c) :c_(), comp_(c)
{ { //
} }
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();
mystl::make_heap(c_.begin(), c_.end(), comp_); mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this; return *this;
} }
~priority_queue() = default; ~priority_queue() = default; //
public: 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();
} } //
void swap(priority_queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)) && void swap(priority_queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)) &&
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_

3476
src/MyTinySTL-master/MyTinySTL/rb_tree.h
View File

File diff suppressed because it is too large Load Diff
Write Preview
Loading…
Cancel
Save