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

我是赵澜博

src/MyTinySTL-master/MyTinySTL/map.h

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

src/MyTinySTL-master/MyTinySTL/memory.h

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

src/MyTinySTL-master/MyTinySTL/numeric.h

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

src/MyTinySTL-master/MyTinySTL/queue.h

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