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

336
src/MyTinySTL-master/MyTinySTL/map.h
Unescape View File

@ -1,20 +1,20 @@
#ifndef MYTINYSTL_MAP_H_ #ifndef MYTINYSTL_MAP_H_ //
#define MYTINYSTL_MAP_H_ #define MYTINYSTL_MAP_H_
//
// 这个头文件包含了两个模板类 map 和 multimap // 这个头文件包含了两个模板类 map 和 multimap
// map : 映射，元素具有键值和实值，会根据键值大小自动排序，键值不允许重复 // map : 映射，元素具有键值和实值，会根据键值大小自动排序，键值不允许重复
// multimap : 映射，元素具有键值和实值，会根据键值大小自动排序，键值允许重复 // multimap : 映射，元素具有键值和实值，会根据键值大小自动排序，键值允许重复
// notes: // notes:
// //
// 异常保证： // 异常保证： //
// mystl::map<Key, T> / mystl::multimap<Key, T> 满足基本异常保证，对以下等函数做强异常安全保证： // mystl::map<Key, T> / mystl::multimap<Key, T> 满足基本异常保证，对以下等函数做强异常安全保证：
// * emplace // * emplace
// * emplace_hint // * emplace_hint //
// * insert // * insert
//
#include "rb_tree.h" #include "rb_tree.h" //
//
namespace mystl namespace mystl
{ {
@ -22,15 +22,15 @@ namespace mystl
// 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less // 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less
template <class Key, class T, class Compare = mystl::less<Key>> template <class Key, class T, class Compare = mystl::less<Key>>
class map class map
{ { //
public: public:
// map 的嵌套型别定义 // map 的嵌套型别定义
typedef Key key_type; typedef Key key_type; //
typedef T mapped_type; typedef T mapped_type;
typedef mystl::pair<const Key, T> value_type; typedef mystl::pair<const Key, T> value_type;
typedef Compare key_compare; typedef Compare key_compare; //
// 定义一个 functor，用来进行元素比较 // 定义一个 functor，用来进行元素比较 //
class value_compare : public binary_function <value_type, value_type, bool> class value_compare : public binary_function <value_type, value_type, bool>
{ {
friend class map<Key, T, Compare>; friend class map<Key, T, Compare>;
@ -38,29 +38,29 @@ public:
Compare comp; Compare comp;
value_compare(Compare c) : comp(c) {} value_compare(Compare c) : comp(c) {}
public: public:
bool operator()(const value_type& lhs, const value_type& rhs) const bool operator()(const value_type& lhs, const value_type& rhs) const //
{ {
return comp(lhs.first, rhs.first); // 比较键值的大小 return comp(lhs.first, rhs.first); // 比较键值的大小
} }
}; }; //
private: private:
// 以 mystl::rb_tree 作为底层机制 // 以 mystl::rb_tree 作为底层机制
typedef mystl::rb_tree<value_type, key_compare> base_type; typedef mystl::rb_tree<value_type, key_compare> base_type; //
base_type tree_; base_type tree_;
public: public: //
// 使用 rb_tree 的型别 // 使用 rb_tree 的型别 //
typedef typename base_type::node_type node_type; typedef typename base_type::node_type node_type;
typedef typename base_type::pointer pointer; typedef typename base_type::pointer pointer; //
typedef typename base_type::const_pointer const_pointer; typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference; typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference; typedef typename base_type::const_reference const_reference;
typedef typename base_type::iterator iterator; typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator; typedef typename base_type::const_iterator const_iterator;
typedef typename base_type::reverse_iterator reverse_iterator; typedef typename base_type::reverse_iterator reverse_iterator; //
typedef typename base_type::const_reverse_iterator const_reverse_iterator; typedef typename base_type::const_reverse_iterator const_reverse_iterator;
typedef typename base_type::size_type size_type; typedef typename base_type::size_type size_type; //
typedef typename base_type::difference_type difference_type; typedef typename base_type::difference_type difference_type;
typedef typename base_type::allocator_type allocator_type; typedef typename base_type::allocator_type allocator_type;
@ -68,22 +68,22 @@ public:
// 构造、复制、移动、赋值函数 // 构造、复制、移动、赋值函数
map() = default; map() = default;
//
template <class InputIterator> template <class InputIterator>
map(InputIterator first, InputIterator last) map(InputIterator first, InputIterator last) //
:tree_() :tree_()
{ tree_.insert_unique(first, last); } { tree_.insert_unique(first, last); } //
map(std::initializer_list<value_type> ilist) map(std::initializer_list<value_type> ilist) //
:tree_() :tree_()
{ tree_.insert_unique(ilist.begin(), ilist.end()); } { tree_.insert_unique(ilist.begin(), ilist.end()); } //
map(const map& rhs) map(const map& rhs) //
:tree_(rhs.tree_) :tree_(rhs.tree_)
{ {
} }
map(map&& rhs) noexcept map(map&& rhs) noexcept //
:tree_(mystl::move(rhs.tree_)) :tree_(mystl::move(rhs.tree_)) //
{ {
} }
@ -92,53 +92,53 @@ public:
tree_ = rhs.tree_; tree_ = rhs.tree_;
return *this; return *this;
} }
map& operator=(map&& rhs) map& operator=(map&& rhs) //
{ { //
tree_ = mystl::move(rhs.tree_); tree_ = mystl::move(rhs.tree_); //
return *this; return *this;
} }
map& operator=(std::initializer_list<value_type> ilist) map& operator=(std::initializer_list<value_type> ilist) //
{ {
tree_.clear(); tree_.clear(); //
tree_.insert_unique(ilist.begin(), ilist.end()); tree_.insert_unique(ilist.begin(), ilist.end());
return *this; return *this; //
} } //
// 相关接口 // 相关接口
//
key_compare key_comp() const { return tree_.key_comp(); } key_compare key_comp() const { return tree_.key_comp(); }
value_compare value_comp() const { return value_compare(tree_.key_comp()); } value_compare value_comp() const { return value_compare(tree_.key_comp()); } //
allocator_type get_allocator() const { return tree_.get_allocator(); } allocator_type get_allocator() const { return tree_.get_allocator(); }
//
// 迭代器相关 // 迭代器相关
//
iterator begin() noexcept iterator begin() noexcept //
{ return tree_.begin(); } { return tree_.begin(); } //
const_iterator begin() const noexcept const_iterator begin() const noexcept
{ return tree_.begin(); } { return tree_.begin(); }
iterator end() noexcept iterator end() noexcept
{ return tree_.end(); } { return tree_.end(); } //
const_iterator end() const noexcept const_iterator end() const noexcept
{ return tree_.end(); } { return tree_.end(); }
//
reverse_iterator rbegin() noexcept reverse_iterator rbegin() noexcept //
{ return reverse_iterator(end()); } { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept const_reverse_iterator rbegin() const noexcept
{ return const_reverse_iterator(end()); } { return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept reverse_iterator rend() noexcept //
{ return reverse_iterator(begin()); } { return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept const_reverse_iterator rend() const noexcept
{ return const_reverse_iterator(begin()); } { return const_reverse_iterator(begin()); }
//
const_iterator cbegin() const noexcept const_iterator cbegin() const noexcept
{ return begin(); } { return begin(); }
const_iterator cend() const noexcept const_iterator cend() const noexcept //
{ return end(); } { return end(); } //
const_reverse_iterator crbegin() const noexcept const_reverse_iterator crbegin() const noexcept
{ return rbegin(); } { return rbegin(); }
const_reverse_iterator crend() const noexcept const_reverse_iterator crend() const noexcept
{ return rend(); } { return rend(); } //
// 容量相关 // 容量相关
bool empty() const noexcept { return tree_.empty(); } bool empty() const noexcept { return tree_.empty(); }
@ -146,18 +146,18 @@ public:
size_type max_size() const noexcept { return tree_.max_size(); } size_type max_size() const noexcept { return tree_.max_size(); }
// 访问元素相关 // 访问元素相关
//
// 若键值不存在，at 会抛出一个异常 // 若键值不存在，at 会抛出一个异常
mapped_type& at(const key_type& key) mapped_type& at(const key_type& key) //
{ {
iterator it = lower_bound(key); iterator it = lower_bound(key);
// it->first >= key // it->first >= key
THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key), THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key), //
"map<Key, T> no such element exists"); "map<Key, T> no such element exists");
return it->second; return it->second; //
} }
const mapped_type& at(const key_type& key) const const mapped_type& at(const key_type& key) const //
{ { //
const_iterator it = lower_bound(key); const_iterator it = lower_bound(key);
// it->first >= key // it->first >= key
THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key), THROW_OUT_OF_RANGE_IF(it == end() || key_comp()(it->first, key),
@ -166,147 +166,147 @@ public:
} }
mapped_type& operator[](const key_type& key) mapped_type& operator[](const key_type& key)
{ { //
iterator it = lower_bound(key); iterator it = lower_bound(key);
// it->first >= key // it->first >= key //
if (it == end() || key_comp()(key, it->first)) if (it == end() || key_comp()(key, it->first))
it = emplace_hint(it, key, T{}); it = emplace_hint(it, key, T{});
return it->second; return it->second;
} }
mapped_type& operator[](key_type&& key) mapped_type& operator[](key_type&& key)
{ { //
iterator it = lower_bound(key); iterator it = lower_bound(key);
// it->first >= key // it->first >= key
if (it == end() || key_comp()(key, it->first)) if (it == end() || key_comp()(key, it->first))
it = emplace_hint(it, mystl::move(key), T{}); it = emplace_hint(it, mystl::move(key), T{}); //
return it->second; return it->second;
} }
// 插入删除相关 // 插入删除相关
template <class ...Args> template <class ...Args> //
pair<iterator, bool> emplace(Args&& ...args) pair<iterator, bool> emplace(Args&& ...args)
{ { //
return tree_.emplace_unique(mystl::forward<Args>(args)...); return tree_.emplace_unique(mystl::forward<Args>(args)...); //
} } //
template <class ...Args> template <class ...Args> //
iterator emplace_hint(iterator hint, Args&& ...args) iterator emplace_hint(iterator hint, Args&& ...args)
{ {
return tree_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...); return tree_.emplace_unique_use_hint(hint, mystl::forward<Args>(args)...); //
} }
pair<iterator, bool> insert(const value_type& value) pair<iterator, bool> insert(const value_type& value)
{ {
return tree_.insert_unique(value); return tree_.insert_unique(value); //
} }
pair<iterator, bool> insert(value_type&& value) pair<iterator, bool> insert(value_type&& value)
{ {
return tree_.insert_unique(mystl::move(value)); return tree_.insert_unique(mystl::move(value)); //
} }
iterator insert(iterator hint, const value_type& value) iterator insert(iterator hint, const value_type& value) //
{ { //
return tree_.insert_unique(hint, value); return tree_.insert_unique(hint, value);
} } //
iterator insert(iterator hint, value_type&& value) iterator insert(iterator hint, value_type&& value)
{ { //
return tree_.insert_unique(hint, mystl::move(value)); return tree_.insert_unique(hint, mystl::move(value));
} }
//
template <class InputIterator> template <class InputIterator> //
void insert(InputIterator first, InputIterator last) void insert(InputIterator first, InputIterator last)
{ {
tree_.insert_unique(first, last); tree_.insert_unique(first, last);
} } //
void erase(iterator position) { tree_.erase(position); } void erase(iterator position) { tree_.erase(position); }
size_type erase(const key_type& key) { return tree_.erase_unique(key); } size_type erase(const key_type& key) { return tree_.erase_unique(key); }
void erase(iterator first, iterator last) { tree_.erase(first, last); } void erase(iterator first, iterator last) { tree_.erase(first, last); } //
void clear() { tree_.clear(); } void clear() { tree_.clear(); }
// map 相关操作 // map 相关操作 //
iterator find(const key_type& key) { return tree_.find(key); } iterator find(const key_type& key) { return tree_.find(key); } //
const_iterator find(const key_type& key) const { return tree_.find(key); } const_iterator find(const key_type& key) const { return tree_.find(key); }
size_type count(const key_type& key) const { return tree_.count_unique(key); } size_type count(const key_type& key) const { return tree_.count_unique(key); }
iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } //
const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); }
iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); }
const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); }
//
pair<iterator, iterator> pair<iterator, iterator>
equal_range(const key_type& key) equal_range(const key_type& key)
{ return tree_.equal_range_unique(key); } { return tree_.equal_range_unique(key); } //
pair<const_iterator, const_iterator> pair<const_iterator, const_iterator>
equal_range(const key_type& key) const equal_range(const key_type& key) const //
{ return tree_.equal_range_unique(key); } { return tree_.equal_range_unique(key); }
//
void swap(map& rhs) noexcept void swap(map& rhs) noexcept
{ tree_.swap(rhs.tree_); } { tree_.swap(rhs.tree_); } //
public: public: //
friend bool operator==(const map& lhs, const map& rhs) { return lhs.tree_ == rhs.tree_; } friend bool operator==(const map& lhs, const map& rhs) { return lhs.tree_ == rhs.tree_; }
friend bool operator< (const map& lhs, const map& rhs) { return lhs.tree_ < rhs.tree_; } friend bool operator< (const map& lhs, const map& rhs) { return lhs.tree_ < rhs.tree_; }
}; };
// 重载比较操作符 // 重载比较操作符
template <class Key, class T, class Compare> template <class Key, class T, class Compare> //
bool operator==(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs) bool operator==(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{ { //
return lhs == rhs; return lhs == rhs;
} }
template <class Key, class T, class Compare> template <class Key, class T, class Compare> //
bool operator<(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs) bool operator<(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs) //
{ {
return lhs < rhs; return lhs < rhs; //
} } //
template <class Key, class T, class Compare> template <class Key, class T, class Compare> //
bool operator!=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs) bool operator!=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{ {
return !(lhs == rhs); return !(lhs == rhs); //
} }
//
template <class Key, class T, class Compare> template <class Key, class T, class Compare> //
bool operator>(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs) bool operator>(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{ { //
return rhs < lhs; return rhs < lhs; //
} } //
template <class Key, class T, class Compare> template <class Key, class T, class Compare>
bool operator<=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs) bool operator<=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{ { //
return !(rhs < lhs); return !(rhs < lhs); //
} }
template <class Key, class T, class Compare> template <class Key, class T, class Compare> //
bool operator>=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs) bool operator>=(const map<Key, T, Compare>& lhs, const map<Key, T, Compare>& rhs)
{ {
return !(lhs < rhs); return !(lhs < rhs);
} } //
// 重载 mystl 的 swap // 重载 mystl 的 swap
template <class Key, class T, class Compare> template <class Key, class T, class Compare>
void swap(map<Key, T, Compare>& lhs, map<Key, T, Compare>& rhs) noexcept void swap(map<Key, T, Compare>& lhs, map<Key, T, Compare>& rhs) noexcept
{ { //
lhs.swap(rhs); lhs.swap(rhs);
} }
//
/*****************************************************************************************/ /*****************************************************************************************/
// 模板类 multimap，键值允许重复 // 模板类 multimap，键值允许重复 //
// 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less // 参数一代表键值类型，参数二代表实值类型，参数三代表键值的比较方式，缺省使用 mystl::less //
template <class Key, class T, class Compare = mystl::less<Key>> template <class Key, class T, class Compare = mystl::less<Key>> //
class multimap class multimap //
{ {
public: public: //
// multimap 的型别定义 // multimap 的型别定义
typedef Key key_type; typedef Key key_type;
typedef T mapped_type; typedef T mapped_type;
@ -322,34 +322,34 @@ public:
value_compare(Compare c) : comp(c) {} value_compare(Compare c) : comp(c) {}
public: public:
bool operator()(const value_type& lhs, const value_type& rhs) const bool operator()(const value_type& lhs, const value_type& rhs) const
{ { //
return comp(lhs.first, rhs.first); return comp(lhs.first, rhs.first);
} }
}; };
private: private:
// 用 mystl::rb_tree 作为底层机制 // 用 mystl::rb_tree 作为底层机制 //
typedef mystl::rb_tree<value_type, key_compare> base_type; typedef mystl::rb_tree<value_type, key_compare> base_type;
base_type tree_; base_type tree_;
public: public:
// 使用 rb_tree 的型别 // 使用 rb_tree 的型别
typedef typename base_type::node_type node_type; typedef typename base_type::node_type node_type; //
typedef typename base_type::pointer pointer; typedef typename base_type::pointer pointer;
typedef typename base_type::const_pointer const_pointer; typedef typename base_type::const_pointer const_pointer;
typedef typename base_type::reference reference; typedef typename base_type::reference reference;
typedef typename base_type::const_reference const_reference; typedef typename base_type::const_reference const_reference; //
typedef typename base_type::iterator iterator; typedef typename base_type::iterator iterator;
typedef typename base_type::const_iterator const_iterator; typedef typename base_type::const_iterator const_iterator; //
typedef typename base_type::reverse_iterator reverse_iterator; typedef typename base_type::reverse_iterator reverse_iterator;
typedef typename base_type::const_reverse_iterator const_reverse_iterator; typedef typename base_type::const_reverse_iterator const_reverse_iterator;
typedef typename base_type::size_type size_type; typedef typename base_type::size_type size_type;
typedef typename base_type::difference_type difference_type; typedef typename base_type::difference_type difference_type;
typedef typename base_type::allocator_type allocator_type; typedef typename base_type::allocator_type allocator_type;
//
public: public:
// 构造、复制、移动函数 // 构造、复制、移动函数
//
multimap() = default; multimap() = default;
template <class InputIterator> template <class InputIterator>
@ -358,7 +358,7 @@ public:
{ tree_.insert_multi(first, last); } { tree_.insert_multi(first, last); }
multimap(std::initializer_list<value_type> ilist) multimap(std::initializer_list<value_type> ilist)
:tree_() :tree_()
{ tree_.insert_multi(ilist.begin(), ilist.end()); } { tree_.insert_multi(ilist.begin(), ilist.end()); } //
multimap(const multimap& rhs) multimap(const multimap& rhs)
:tree_(rhs.tree_) :tree_(rhs.tree_)
@ -367,78 +367,78 @@ public:
multimap(multimap&& rhs) noexcept multimap(multimap&& rhs) noexcept
:tree_(mystl::move(rhs.tree_)) :tree_(mystl::move(rhs.tree_))
{ {
} } //
//
multimap& operator=(const multimap& rhs) multimap& operator=(const multimap& rhs)
{ { //
tree_ = rhs.tree_; tree_ = rhs.tree_;
return *this; return *this;
} }
multimap& operator=(multimap&& rhs) multimap& operator=(multimap&& rhs)
{ {
tree_ = mystl::move(rhs.tree_); tree_ = mystl::move(rhs.tree_); //
return *this; return *this;
} } //
multimap& operator=(std::initializer_list<value_type> ilist) multimap& operator=(std::initializer_list<value_type> ilist) //
{ {
tree_.clear(); tree_.clear(); //
tree_.insert_multi(ilist.begin(), ilist.end()); tree_.insert_multi(ilist.begin(), ilist.end()); //
return *this; return *this;
} } //
// 相关接口 // 相关接口
key_compare key_comp() const { return tree_.key_comp(); } key_compare key_comp() const { return tree_.key_comp(); }
value_compare value_comp() const { return value_compare(tree_.key_comp()); } value_compare value_comp() const { return value_compare(tree_.key_comp()); }
allocator_type get_allocator() const { return tree_.get_allocator(); } allocator_type get_allocator() const { return tree_.get_allocator(); }
//
// 迭代器相关 // 迭代器相关
//
iterator begin() noexcept iterator begin() noexcept
{ return tree_.begin(); } { return tree_.begin(); }
const_iterator begin() const noexcept const_iterator begin() const noexcept //
{ return tree_.begin(); } { return tree_.begin(); }
iterator end() noexcept iterator end() noexcept
{ return tree_.end(); } { return tree_.end(); } //
const_iterator end() const noexcept const_iterator end() const noexcept
{ return tree_.end(); } { return tree_.end(); }
reverse_iterator rbegin() noexcept reverse_iterator rbegin() noexcept
{ return reverse_iterator(end()); } { return reverse_iterator(end()); }
const_reverse_iterator rbegin() const noexcept const_reverse_iterator rbegin() const noexcept //
{ return const_reverse_iterator(end()); } { return const_reverse_iterator(end()); }
reverse_iterator rend() noexcept reverse_iterator rend() noexcept
{ return reverse_iterator(begin()); } { return reverse_iterator(begin()); }
const_reverse_iterator rend() const noexcept const_reverse_iterator rend() const noexcept //
{ return const_reverse_iterator(begin()); } { return const_reverse_iterator(begin()); }
const_iterator cbegin() const noexcept const_iterator cbegin() const noexcept
{ return begin(); } { return begin(); } //
const_iterator cend() const noexcept const_iterator cend() const noexcept
{ return end(); } { return end(); } //
const_reverse_iterator crbegin() const noexcept const_reverse_iterator crbegin() const noexcept
{ return rbegin(); } { return rbegin(); } //
const_reverse_iterator crend() const noexcept const_reverse_iterator crend() const noexcept
{ return rend(); } { return rend(); }
// 容量相关 // 容量相关
bool empty() const noexcept { return tree_.empty(); } bool empty() const noexcept { return tree_.empty(); }
size_type size() const noexcept { return tree_.size(); } size_type size() const noexcept { return tree_.size(); } //
size_type max_size() const noexcept { return tree_.max_size(); } size_type max_size() const noexcept { return tree_.max_size(); }
//
// 插入删除操作 // 插入删除操作
//
template <class ...Args> template <class ...Args>
iterator emplace(Args&& ...args) iterator emplace(Args&& ...args) //
{ {
return tree_.emplace_multi(mystl::forward<Args>(args)...); return tree_.emplace_multi(mystl::forward<Args>(args)...);
} }
//
template <class ...Args> template <class ...Args>
iterator emplace_hint(iterator hint, Args&& ...args) iterator emplace_hint(iterator hint, Args&& ...args) //
{ {
return tree_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...); return tree_.emplace_multi_use_hint(hint, mystl::forward<Args>(args)...); //
} }
iterator insert(const value_type& value) iterator insert(const value_type& value)
@ -446,9 +446,9 @@ public:
return tree_.insert_multi(value); return tree_.insert_multi(value);
} }
iterator insert(value_type&& value) iterator insert(value_type&& value)
{ { //
return tree_.insert_multi(mystl::move(value)); return tree_.insert_multi(mystl::move(value));
} } //
iterator insert(iterator hint, const value_type& value) iterator insert(iterator hint, const value_type& value)
{ {
@ -456,45 +456,45 @@ public:
} }
iterator insert(iterator hint, value_type&& value) iterator insert(iterator hint, value_type&& value)
{ {
return tree_.insert_multi(hint, mystl::move(value)); return tree_.insert_multi(hint, mystl::move(value)); //
} }
template <class InputIterator> template <class InputIterator>
void insert(InputIterator first, InputIterator last) void insert(InputIterator first, InputIterator last) //
{ {
tree_.insert_multi(first, last); tree_.insert_multi(first, last); //
} }
void erase(iterator position) { tree_.erase(position); } void erase(iterator position) { tree_.erase(position); }
size_type erase(const key_type& key) { return tree_.erase_multi(key); } size_type erase(const key_type& key) { return tree_.erase_multi(key); } //
void erase(iterator first, iterator last) { tree_.erase(first, last); } void erase(iterator first, iterator last) { tree_.erase(first, last); }
//
void clear() { tree_.clear(); } void clear() { tree_.clear(); }
// multimap 相关操作 // multimap 相关操作
iterator find(const key_type& key) { return tree_.find(key); } iterator find(const key_type& key) { return tree_.find(key); }
const_iterator find(const key_type& key) const { return tree_.find(key); } const_iterator find(const key_type& key) const { return tree_.find(key); } //
size_type count(const key_type& key) const { return tree_.count_multi(key); } size_type count(const key_type& key) const { return tree_.count_multi(key); }
iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } iterator lower_bound(const key_type& key) { return tree_.lower_bound(key); } //
const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); } const_iterator lower_bound(const key_type& key) const { return tree_.lower_bound(key); }
iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } iterator upper_bound(const key_type& key) { return tree_.upper_bound(key); } //
const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } const_iterator upper_bound(const key_type& key) const { return tree_.upper_bound(key); } //
pair<iterator, iterator> pair<iterator, iterator>
equal_range(const key_type& key) equal_range(const key_type& key)
{ return tree_.equal_range_multi(key); } { return tree_.equal_range_multi(key); }
//
pair<const_iterator, const_iterator> pair<const_iterator, const_iterator>
equal_range(const key_type& key) const equal_range(const key_type& key) const
{ return tree_.equal_range_multi(key); } { return tree_.equal_range_multi(key); }
void swap(multimap& rhs) noexcept void swap(multimap& rhs) noexcept
{ tree_.swap(rhs.tree_); } { tree_.swap(rhs.tree_); }
//
public: public:
friend bool operator==(const multimap& lhs, const multimap& rhs) { return lhs.tree_ == rhs.tree_; } friend bool operator==(const multimap& lhs, const multimap& rhs) { return lhs.tree_ == rhs.tree_; }
friend bool operator< (const multimap& lhs, const multimap& rhs) { return lhs.tree_ < rhs.tree_; } friend bool operator< (const multimap& lhs, const multimap& rhs) { return lhs.tree_ < rhs.tree_; }
@ -502,7 +502,7 @@ public:
// 重载比较操作符 // 重载比较操作符
template <class Key, class T, class Compare> template <class Key, class T, class Compare>
bool operator==(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) bool operator==(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) //
{ {
return lhs == rhs; return lhs == rhs;
} }
@ -510,40 +510,40 @@ bool operator==(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Com
template <class Key, class T, class Compare> template <class Key, class T, class Compare>
bool operator<(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) bool operator<(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{ {
return lhs < rhs; return lhs < rhs; //
} } //
template <class Key, class T, class Compare> template <class Key, class T, class Compare>
bool operator!=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) bool operator!=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) //
{ {
return !(lhs == rhs); return !(lhs == rhs);
} }
//
template <class Key, class T, class Compare> template <class Key, class T, class Compare>
bool operator>(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) bool operator>(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{ {
return rhs < lhs; return rhs < lhs;
} }
//
template <class Key, class T, class Compare> template <class Key, class T, class Compare>
bool operator<=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) bool operator<=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) //
{ {
return !(rhs < lhs); return !(rhs < lhs);
} } //
//
template <class Key, class T, class Compare> template <class Key, class T, class Compare>
bool operator>=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs) bool operator>=(const multimap<Key, T, Compare>& lhs, const multimap<Key, T, Compare>& rhs)
{ { //
return !(lhs < rhs); return !(lhs < rhs); //
} }
//
// 重载 mystl 的 swap // 重载 mystl 的 swap
template <class Key, class T, class Compare> template <class Key, class T, class Compare> //
void swap(multimap<Key, T, Compare>& lhs, multimap<Key, T, Compare>& rhs) noexcept void swap(multimap<Key, T, Compare>& lhs, multimap<Key, T, Compare>& rhs) noexcept
{ {
lhs.swap(rhs); lhs.swap(rhs);
} } //
} // namespace mystl } // namespace mystl
#endif // !MYTINYSTL_MAP_H_ #endif // !MYTINYSTL_MAP_H_
//

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

@ -1,7 +1,7 @@
#ifndef MYTINYSTL_MEMORY_H_ #ifndef MYTINYSTL_MEMORY_H_ //
#define MYTINYSTL_MEMORY_H_ #define MYTINYSTL_MEMORY_H_
// 这个头文件负责更高级的动态内存管理 // 这个头文件负责更高级的动态内存管理 //
// 包含一些基本函数、空间配置器、未初始化的储存空间管理，以及一个模板类 auto_ptr // 包含一些基本函数、空间配置器、未初始化的储存空间管理，以及一个模板类 auto_ptr
#include <cstddef> #include <cstddef>
@ -10,35 +10,35 @@
#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)
@ -46,23 +46,23 @@ 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; // 缓冲区申请的大小
@ -70,139 +70,139 @@ private:
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_ //

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

@ -1,4 +1,4 @@
#ifndef MYTINYSTL_NUMERIC_H_ #ifndef MYTINYSTL_NUMERIC_H_ //
#define MYTINYSTL_NUMERIC_H_ #define MYTINYSTL_NUMERIC_H_
// 这个头文件包含了 mystl 的数值算法 // 这个头文件包含了 mystl 的数值算法
@ -6,63 +6,63 @@
#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)
{ {
@ -70,7 +70,7 @@ OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter resul
*++result = binary_op(tmp, value); *++result = binary_op(tmp, value);
value = tmp; value = tmp;
} }
return ++result; return ++result; //
} }
/*****************************************************************************************/ /*****************************************************************************************/
@ -78,78 +78,78 @@ OutputIter adjacent_difference(InputIter first, InputIter last, OutputIter resul
// 版本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_ //

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

@ -1,247 +1,247 @@
#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_)
@ -250,47 +250,47 @@ public:
} }
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_);
} }
@ -298,9 +298,9 @@ public:
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_);
@ -310,47 +310,47 @@ public:
{ {
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,
@ -358,7 +358,7 @@ void swap(priority_queue<T, Container, Compare>& lhs,
{ {
lhs.swap(rhs); lhs.swap(rhs);
} }
//
} // namespace mystl } // namespace mystl
#endif // !MYTINYSTL_QUEUE_H_ #endif // !MYTINYSTL_QUEUE_H_

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

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