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

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

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

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

@ -1,364 +1,364 @@
#ifndef MYTINYSTL_QUEUE_H_
#define MYTINYSTL_QUEUE_H_
// 这个头文件包含了两个模板类 queue 和 priority_queue
// queue : 队列
// priority_queue : 优先队列
#include "deque.h"
#include "vector.h"
#include "functional.h"
#include "heap_algo.h"
namespace mystl
{
// 模板类 queue
// 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器
template <class T, class Container = mystl::deque<T>>
class queue
{
public:
typedef Container container_type;
// 使用底层容器的型别
typedef typename Container::value_type value_type;
typedef typename Container::size_type size_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
static_assert(std::is_same<T, value_type>::value,
"the value_type of Container should be same with T");
private:
container_type c_; // 用底层容器表现 queue
public:
// 构造、复制、移动函数
queue() = default;
explicit queue(size_type n)
:c_(n)
{
}
queue(size_type n, const value_type& value)
:c_(n, value)
{
}
template <class IIter>
queue(IIter first, IIter last)
:c_(first, last)
{
}
queue(std::initializer_list<T> ilist)
:c_(ilist.begin(), ilist.end())
{
}
queue(const Container& c)
:c_(c)
{
}
queue(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value)
:c_(mystl::move(c))
{
}
queue(const queue& rhs)
:c_(rhs.c_)
{
}
queue(queue&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::value)
:c_(mystl::move(rhs.c_))
{
}
queue& operator=(const queue& rhs)
{
c_ = rhs.c_;
return *this;
}
queue& operator=(queue&& rhs) noexcept(std::is_nothrow_move_assignable<Container>::value)
{
c_ = mystl::move(rhs.c_);
return *this;
}
queue& operator=(std::initializer_list<T> ilist)
{
c_ = ilist;
return *this;
}
~queue() = default;
// 访问元素相关操作
reference front() { return c_.front(); }
const_reference front() const { return c_.front(); }
reference back() { return c_.back(); }
const_reference back() const { return c_.back(); }
// 容量相关操作
bool empty() const noexcept { return c_.empty(); }
size_type size() const noexcept { return c_.size(); }
// 修改容器相关操作
template <class ...Args>
void emplace(Args&& ...args)
{ c_.emplace_back(mystl::forward<Args>(args)...); }
void push(const value_type& value)
{ c_.push_back(value); }
void push(value_type&& value)
{ c_.emplace_back(mystl::move(value)); }
void pop()
{ c_.pop_front(); }
void clear()
{
while (!empty())
pop();
}
void swap(queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)))
{ mystl::swap(c_, rhs.c_); }
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_; }
};
// 重载比较操作符
template <class T, class Container>
bool operator==(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return lhs == rhs;
}
template <class T, class Container>
bool operator!=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return !(lhs == rhs);
}
template <class T, class Container>
bool operator<(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return lhs < rhs;
}
template <class T, class Container>
bool operator>(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return rhs < lhs;
}
template <class T, class Container>
bool operator<=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return !(rhs < lhs);
}
template <class T, class Container>
bool operator>=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return !(lhs < rhs);
}
// 重载 mystl 的 swap
template <class T, class Container>
void swap(queue<T, Container>& lhs, queue<T, Container>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
/*****************************************************************************************/
// 模板类 priority_queue
// 参数一代表数据类型，参数二代表容器类型，缺省使用 mystl::vector 作为底层容器
// 参数三代表比较权值的方式，缺省使用 mystl::less 作为比较方式
template <class T, class Container = mystl::vector<T>,
class Compare = mystl::less<typename Container::value_type>>
class priority_queue
{
public:
typedef Container container_type;
typedef Compare value_compare;
// 使用底层容器的型别
typedef typename Container::value_type value_type;
typedef typename Container::size_type size_type;
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference;
static_assert(std::is_same<T, value_type>::value,
"the value_type of Container should be same with T");
private:
container_type c_; // 用底层容器来表现 priority_queue
value_compare comp_; // 权值比较的标准
public:
// 构造、复制、移动函数
priority_queue() = default;
priority_queue(const Compare& c)
:c_(), comp_(c)
{
}
explicit priority_queue(size_type n)
:c_(n)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(size_type n, const value_type& value)
:c_(n, value)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
template <class IIter>
priority_queue(IIter first, IIter last)
:c_(first, last)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(std::initializer_list<T> ilist)
:c_(ilist)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(const Container& s)
:c_(s)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(Container&& s)
:c_(mystl::move(s))
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(const priority_queue& rhs)
:c_(rhs.c_), comp_(rhs.comp_)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(priority_queue&& rhs)
:c_(mystl::move(rhs.c_)), comp_(rhs.comp_)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue& operator=(const priority_queue& rhs)
{
c_ = rhs.c_;
comp_ = rhs.comp_;
mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this;
}
priority_queue& operator=(priority_queue&& rhs)
{
c_ = mystl::move(rhs.c_);
comp_ = rhs.comp_;
mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this;
}
priority_queue& operator=(std::initializer_list<T> ilist)
{
c_ = ilist;
comp_ = value_compare();
mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this;
}
~priority_queue() = default;
public:
// 访问元素相关操作
const_reference top() const { return c_.front(); }
// 容量相关操作
bool empty() const noexcept { return c_.empty(); }
size_type size() const noexcept { return c_.size(); }
// 修改容器相关操作
template <class... Args>
void emplace(Args&& ...args)
{
c_.emplace_back(mystl::forward<Args>(args)...);
mystl::push_heap(c_.begin(), c_.end(), comp_);
}
void push(const value_type& value)
{
c_.push_back(value);
mystl::push_heap(c_.begin(), c_.end(), comp_);
}
void push(value_type&& value)
{
c_.push_back(mystl::move(value));
mystl::push_heap(c_.begin(), c_.end(), comp_);
}
void pop()
{
mystl::pop_heap(c_.begin(), c_.end(), comp_);
c_.pop_back();
}
void clear()
{
while (!empty())
pop();
}
void swap(priority_queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)) &&
noexcept(mystl::swap(comp_, rhs.comp_)))
{
mystl::swap(c_, rhs.c_);
mystl::swap(comp_, rhs.comp_);
}
public:
friend bool operator==(const priority_queue& lhs, const priority_queue& rhs)
{
return lhs.c_ == rhs.c_;
}
friend bool operator!=(const priority_queue& lhs, const priority_queue& rhs)
{
return lhs.c_ != rhs.c_;
}
};
// 重载比较操作符
template <class T, class Container, class Compare>
bool operator==(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs)
{
return lhs == rhs;
}
template <class T, class Container, class Compare>
bool operator!=(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs)
{
return lhs != rhs;
}
// 重载 mystl 的 swap
template <class T, class Container, class Compare>
void swap(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
} // namespace mystl
#endif // !MYTINYSTL_QUEUE_H_
#ifndef MYTINYSTL_QUEUE_H_ //
#define MYTINYSTL_QUEUE_H_
// 这个头文件包含了两个模板类 queue 和 priority_queue //
// queue : 队列
// priority_queue : 优先队列
#include "deque.h"
#include "vector.h" //
#include "functional.h"
#include "heap_algo.h"
namespace mystl //
{
// 模板类 queue //
// 参数一代表数据类型，参数二代表底层容器类型，缺省使用 mystl::deque 作为底层容器 //
template <class T, class Container = mystl::deque<T>>
class queue //
{
public:
typedef Container container_type;
// 使用底层容器的型别
typedef typename Container::value_type value_type;
typedef typename Container::size_type size_type; //
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference; //
//
static_assert(std::is_same<T, value_type>::value,
"the value_type of Container should be same with T");
private: //
container_type c_; // 用底层容器表现 queue
public:
// 构造、复制、移动函数
queue() = default; //
explicit queue(size_type n) //
:c_(n) //
{ //
}
queue(size_type n, const value_type& value) //
:c_(n, value)
{ //
}
template <class IIter>
queue(IIter first, IIter last) //
:c_(first, last)
{
}
queue(std::initializer_list<T> ilist)
:c_(ilist.begin(), ilist.end())
{ //
} //
queue(const Container& c)
:c_(c)
{ //
}
queue(Container&& c) noexcept(std::is_nothrow_move_constructible<Container>::value) //
:c_(mystl::move(c))
{
}
//
queue(const queue& rhs)
:c_(rhs.c_)
{
} //
queue(queue&& rhs) noexcept(std::is_nothrow_move_constructible<Container>::value)
:c_(mystl::move(rhs.c_)) //
{
}
//
queue& operator=(const queue& rhs) //
{
c_ = rhs.c_; //
return *this;
} //
queue& operator=(queue&& rhs) noexcept(std::is_nothrow_move_assignable<Container>::value) //
{
c_ = mystl::move(rhs.c_);
return *this; //
}
//
queue& operator=(std::initializer_list<T> ilist)
{ //
c_ = ilist;
return *this; //
}
//
~queue() = default;
// 访问元素相关操作
reference front() { return c_.front(); } //
const_reference front() const { return c_.front(); }
reference back() { return c_.back(); }
const_reference back() const { return c_.back(); }
//
// 容量相关操作
bool empty() const noexcept { return c_.empty(); } //
size_type size() const noexcept { return c_.size(); }
// 修改容器相关操作 //
template <class ...Args>
void emplace(Args&& ...args)
{ c_.emplace_back(mystl::forward<Args>(args)...); } //
void push(const value_type& value)
{ c_.push_back(value); } //
void push(value_type&& value)
{ c_.emplace_back(mystl::move(value)); }
//
void pop() //
{ c_.pop_front(); }
void clear()
{
while (!empty()) //
pop();
}
void swap(queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_))) //
{ mystl::swap(c_, rhs.c_); }
//
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_; }
};
// 重载比较操作符 //
template <class T, class Container>
bool operator==(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ //
return lhs == rhs;
}
template <class T, class Container>
bool operator!=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) //
{ //
return !(lhs == rhs); //
}
template <class T, class Container>
bool operator<(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return lhs < rhs; //
}
//
template <class T, class Container>
bool operator>(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{
return rhs < lhs;
}
//
template <class T, class Container>
bool operator<=(const queue<T, Container>& lhs, const queue<T, Container>& rhs)
{ //
return !(rhs < lhs);
}
//
template <class T, class Container>
bool operator>=(const queue<T, Container>& lhs, const queue<T, Container>& rhs) //
{
return !(lhs < rhs); //
}
//
// 重载 mystl 的 swap
template <class T, class Container>
void swap(queue<T, Container>& lhs, queue<T, Container>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
} //
/*****************************************************************************************/
// 模板类 priority_queue
// 参数一代表数据类型，参数二代表容器类型，缺省使用 mystl::vector 作为底层容器
// 参数三代表比较权值的方式，缺省使用 mystl::less 作为比较方式 //
template <class T, class Container = mystl::vector<T>,
class Compare = mystl::less<typename Container::value_type>>
class priority_queue
{ //
public: //
typedef Container container_type;
typedef Compare value_compare;
// 使用底层容器的型别
typedef typename Container::value_type value_type;
typedef typename Container::size_type size_type; //
typedef typename Container::reference reference;
typedef typename Container::const_reference const_reference; //
static_assert(std::is_same<T, value_type>::value,
"the value_type of Container should be same with T"); //
//
private:
container_type c_; // 用底层容器来表现 priority_queue //
value_compare comp_; // 权值比较的标准
//
public:
// 构造、复制、移动函数
priority_queue() = default;
//
priority_queue(const Compare& c) //
:c_(), comp_(c)
{ //
}
explicit priority_queue(size_type n) //
:c_(n)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(size_type n, const value_type& value)
:c_(n, value) //
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
} //
//
template <class IIter>
priority_queue(IIter first, IIter last)
:c_(first, last)
{ //
mystl::make_heap(c_.begin(), c_.end(), comp_); //
} //
priority_queue(std::initializer_list<T> ilist) //
:c_(ilist)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
} //
priority_queue(const Container& s)
:c_(s)
{ //
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(Container&& s)
:c_(mystl::move(s)) //
{
mystl::make_heap(c_.begin(), c_.end(), comp_); //
} //
priority_queue(const priority_queue& rhs)
:c_(rhs.c_), comp_(rhs.comp_)
{
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
priority_queue(priority_queue&& rhs)
:c_(mystl::move(rhs.c_)), comp_(rhs.comp_)
{ //
mystl::make_heap(c_.begin(), c_.end(), comp_);
}
//
priority_queue& operator=(const priority_queue& rhs)
{
c_ = rhs.c_;
comp_ = rhs.comp_;
mystl::make_heap(c_.begin(), c_.end(), comp_); //
return *this;
}
priority_queue& operator=(priority_queue&& rhs)
{
c_ = mystl::move(rhs.c_); //
comp_ = rhs.comp_;
mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this; //
}
priority_queue& operator=(std::initializer_list<T> ilist) //
{
c_ = ilist; //
comp_ = value_compare();
mystl::make_heap(c_.begin(), c_.end(), comp_);
return *this;
}
~priority_queue() = default; //
public:
// 访问元素相关操作
const_reference top() const { return c_.front(); }
//
// 容量相关操作
bool empty() const noexcept { return c_.empty(); }
size_type size() const noexcept { return c_.size(); }
//
// 修改容器相关操作
template <class... Args> //
void emplace(Args&& ...args) //
{ //
c_.emplace_back(mystl::forward<Args>(args)...);
mystl::push_heap(c_.begin(), c_.end(), comp_);
}
void push(const value_type& value)
{
c_.push_back(value);
mystl::push_heap(c_.begin(), c_.end(), comp_); //
}
void push(value_type&& value) //
{
c_.push_back(mystl::move(value));
mystl::push_heap(c_.begin(), c_.end(), comp_);
}
void pop()
{
mystl::pop_heap(c_.begin(), c_.end(), comp_);
c_.pop_back();
} //
void clear()
{ //
while (!empty()) //
pop();
} //
void swap(priority_queue& rhs) noexcept(noexcept(mystl::swap(c_, rhs.c_)) &&
noexcept(mystl::swap(comp_, rhs.comp_)))
{
mystl::swap(c_, rhs.c_);
mystl::swap(comp_, rhs.comp_); //
} //
public:
friend bool operator==(const priority_queue& lhs, const priority_queue& rhs) //
{
return lhs.c_ == rhs.c_;
}
friend bool operator!=(const priority_queue& lhs, const priority_queue& rhs) //
{
return lhs.c_ != rhs.c_;
}
};
// 重载比较操作符 //
template <class T, class Container, class Compare>
bool operator==(priority_queue<T, Container, Compare>& lhs, //
priority_queue<T, Container, Compare>& rhs)
{ //
return lhs == rhs;
} //
//
template <class T, class Container, class Compare>
bool operator!=(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs) //
{
return lhs != rhs;
}
//
// 重载 mystl 的 swap
template <class T, class Container, class Compare>
void swap(priority_queue<T, Container, Compare>& lhs,
priority_queue<T, Container, Compare>& rhs) noexcept(noexcept(lhs.swap(rhs)))
{
lhs.swap(rhs);
}
//
} // namespace mystl
#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