2. 程式人生 > >C++中map和set的使用與區別

C++中map和set的使用與區別

阿新 • • 發佈：2018-12-16

set

set是一種關聯式容器，其特性如下：

  1. set以RBTree作為底層容器
  2. 所得元素的只有key沒有value，value就是key
  3. 不允許出現鍵值重複
  4. 所有的元素都會被自動排序
  5. 不能通過迭代器來改變set的值，因為set的值就是鍵

針對這五點來說，前四點都不用再多作說明，第五點需要做一下說明。如果set中允許修改鍵值的話，那麼首先需要刪除該鍵，然後調節平衡，在插入修改後的鍵值，再調節平衡，如此一來，嚴重破壞了set的結構，導致iterator失效，不知道應該指向之前的位置，還是指向改變後的位置。所以STL中將set的迭代器設定成const，不允許修改迭代器的值。

set的資料結構

// 比較器預設採用less，內部按照升序排列，配置器預設採用alloc
template <class Key, class Compare = less<Key>, class Alloc = alloc>
class set
{
public:
  //  在set中key就是value, value同時也是key
  typedef Key key_type;
  typedef Key value_type;
 
  // 用於比較的函式
  typedef Compare key_compare;
  typedef Compare value_compare;
 
private:
  // 內部採用RBTree作為底層容器
  typedef rb_tree<key_type, value_type,
                  identity<value_type>, key_compare, Alloc> rep_type;
  rep_type t;   // t為內部RBTree容器
 
public:
  // 用於提供iterator_traits<I>支援
  typedef typename rep_type::const_pointer pointer;            
  typedef typename rep_type::const_pointer const_pointer;
  typedef typename rep_type::const_reference reference;        
  typedef typename rep_type::const_reference const_reference;
  typedef typename rep_type::difference_type difference_type; 
  // 設定成const迭代器，set的鍵值不允許修改
  typedef typename rep_type::const_iterator iterator;          
  typedef typename rep_type::const_iterator const_iterator;
  // 反向迭代器
  typedef typename rep_type::const_reverse_iterator reverse_iterator;
  typedef typename rep_type::const_reverse_iterator const_reverse_iterator;
  typedef typename rep_type::size_type size_type;
 
  iterator begin() const { return t.begin(); }
  iterator end() const { return t.end(); }
  reverse_iterator rbegin() const { return t.rbegin(); }
  reverse_iterator rend() const { return t.rend(); }
  bool empty() const { return t.empty(); }
  size_type size() const { return t.size(); }
  size_type max_size() const { return t.max_size(); }
 
  // 返回用於key比較的函式
  key_compare key_comp() const { return t.key_comp(); }
  // 由於set的性質, value比較和key使用同一個比較函式
  value_compare value_comp() const { return t.key_comp(); }
 
  // 聲明瞭兩個友元函式，過載了==和<操作符
  friend bool operator== __STL_NULL_TMPL_ARGS (const set&, const set&);
  friend bool operator< __STL_NULL_TMPL_ARGS (const set&, const set&);
  // ...
}


set的建構函式
set提供瞭如下幾個建構函式用於初始化一個set

// 注：下面相關函式都在set類中定義，為了介紹方便才抽出來單獨講解
// 空建構函式，初始化一個空的set
set() : t(Compare()) {}
// 支援自定義比較器，如set<int,greater<int> > myset的初始化
explicit set(const Compare& comp) : t(comp) {}
// 實現諸如set<int> myset(anotherset.begin(),anotherset.end())這樣的初始化
template <class InputIterator>
set(InputIterator first, InputIterator last)
: t(Compare()) { t.insert_unique(first, last); }
// 支援自定義比較器的初始化操作
template <class InputIterator>
set(InputIterator first, InputIterator last, const Compare& comp)
: t(comp) { t.insert_unique(first, last); }
// 以另一個set來初始化
set(const set<Key, Compare, Alloc>& x) : t(x.t) {}
// 賦值運算子函式
set<Key, Compare, Alloc>& operator=(const set<Key, Compare, Alloc>& x)
{
    t = x.t;
    return *this;
}


set的操作函式
insert

插入函式，呼叫RBTree的插入函式即可typedef  pair<iterator, bool> pair_iterator_bool;
// 由於set不允許鍵值重複，所以必須呼叫RBTree的insert_unique函式
// second表示插入操作是否成功
pair<iterator,bool> insert(const value_type& x)
{
  pair<typename rep_type::iterator, bool> p = t.insert_unique(x);
  return pair<iterator, bool>(p.first, p.second);
}
 
// 在position處插入元素, 但是position僅僅是個提示, 如果給出的位置不能進行插入,
// STL會進行查詢, 這會導致很差的效率
iterator insert(iterator position, const value_type& x)
{
  typedef typename rep_type::iterator rep_iterator;
  return t.insert_unique((rep_iterator&)position, x);
}
// 將[first，last)區間內的元素插入到set中
template <class InputIterator>
void insert(InputIterator first, InputIterator last)
{
  t.insert_unique(first, last);
}


erase

擦除函式，用於擦除單個元素或者區間內的元素，直接呼叫RBTree的函式即可

// 擦除指定位置的元素, 會導致內部的紅黑樹重新排列
void erase(iterator position)
{
  typedef typename rep_type::iterator rep_iterator;
  t.erase((rep_iterator&)position);
}
 
// 會返回擦除元素的個數, 其實就是標識set內原來是否有指定的元素
size_type erase(const key_type& x)
{
  return t.erase(x);
}
 
// 擦除指定區間的元素, 會導致紅黑樹有較大變化
void erase(iterator first, iterator last)
{
  typedef typename rep_type::iterator rep_iterator;
  t.erase((rep_iterator&)first, (rep_iterator&)last);
}


clean

清除整個set容器，直接呼叫RBTree的clean函式即可void clear() { t.clear(); }


find

查詢函式，RBTree也提供了，直接呼叫即可

// 查詢指定的元素
  iterator find(const key_type& x) const { return t.find(x); }


count

查詢制定元素的個數// 返回指定元素的個數, set不允許鍵值重複，其實就是測試元素是否在set中
  size_type count(const key_type& x) const { return t.count(x); }


過載操作符

set過載了==和<操作符，基本上都是呼叫RBTree的介面函式即可，如下所示：

template <class Key, class Compare, class Alloc>
inline bool operator==(const set<Key, Compare, Alloc>& x,
                       const set<Key, Compare, Alloc>& y) {
  return x.t == y.t;
}
 
template <class Key, class Compare, class Alloc>
inline bool operator<(const set<Key, Compare, Alloc>& x,
                      const set<Key, Compare, Alloc>& y) {
  return x.t < y.t;
}
其他操作函式
// 返回小於當前元素的第一個可插入的位置
iterator lower_bound(const key_type& x) const
{
  return t.lower_bound(x);
}
 
// 返回大於當前元素的第一個可插入的位置
iterator upper_bound(const key_type& x) const
{
  return t.upper_bound(x);
}
// 返回與指定鍵值相等的元素區間
pair<iterator,iterator> equal_range(const key_type& x) const
{
  return t.equal_range(x);
}


multiset
multiset相對於set來說，區別就是multiset允許鍵值重複，在multiset中呼叫的是RBTree的insert_equal函式，其他的基本與set相同。

其他的就不贅述了，下面列舉一下跟set不同的地方：

// 初始化函式，
// 注意！！！！插入操作採用的是RBTree的insert_equal，而不是insert_unique
template <class InputIterator>
multiset(InputIterator first, InputIterator last)
  : t(Compare()) { t.insert_equal(first, last); }
template <class InputIterator>
multiset(InputIterator first, InputIterator last, const Compare& comp)
  : t(comp) { t.insert_equal(first, last); }
 
// 插入元素, 注意, 插入的元素key允許重複
iterator insert(const value_type& x)
{
  return t.insert_equal(x);
}
 
// 在position處插入元素, 但是position僅僅是個提示, 如果給出的位置不能進行插入,
// STL會進行查詢, 這會導致很差的效率
iterator insert(iterator position, const value_type& x)
{
  typedef typename rep_type::iterator rep_iterator;
  return t.insert_equal((rep_iterator&)position, x);
}


map
map和set一樣是關聯式容器，它們的底層容器都是紅黑樹，區別就在於map的值不作為鍵，鍵和值是分開的。它的特性如下：

  1. map以RBTree作為底層容器
  2. 所有元素都是鍵+值存在
  3. 不允許鍵重複
  4. 所有元素是通過鍵進行自動排序的
  5. map的鍵是不能修改的，但是其鍵對應的值是可以修改的

在map中，一個鍵對應一個值，其中鍵不允許重複，不允許修改，但是鍵對應的值是可以修改的，原因可以看上面set中的解釋。下面就一起來看看STL中的map的原始碼。

map的資料結構

// 預設比較器為less<key>,元素按照鍵的大小升序排列
template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>
class map {
public:
  typedef Key key_type;                         // key型別
  typedef T data_type;                          // value型別
  typedef T mapped_type;
  typedef pair<const Key, T> value_type;        // 元素型別, 要保證key不被修改
  typedef Compare key_compare;                  // 用於key比較的函式
private:
  // 內部採用RBTree作為底層容器
  typedef rb_tree<key_type, value_type,
                  identity<value_type>, key_compare, Alloc> rep_type;
  rep_type t; // t為內部RBTree容器
public:
  // 用於提供iterator_traits<I>支援
  typedef typename rep_type::const_pointer pointer;            
  typedef typename rep_type::const_pointer const_pointer;
  typedef typename rep_type::const_reference reference;        
  typedef typename rep_type::const_reference const_reference;
  typedef typename rep_type::difference_type difference_type; 
  // 注意：這裡與set不一樣，map的迭代器是可以修改的
  typedef typename rep_type::iterator iterator;          
  typedef typename rep_type::const_iterator const_iterator;
  // 反向迭代器
  typedef typename rep_type::const_reverse_iterator reverse_iterator;
  typedef typename rep_type::const_reverse_iterator const_reverse_iterator;
  typedef typename rep_type::size_type size_type;
 
  // 常規的返回迭代器函式
  iterator begin() { return t.begin(); }
  const_iterator begin() const { return t.begin(); }
  iterator end() { return t.end(); }
  const_iterator end() const { return t.end(); }
  reverse_iterator rbegin() { return t.rbegin(); }
  const_reverse_iterator rbegin() const { return t.rbegin(); }
  reverse_iterator rend() { return t.rend(); }
  const_reverse_iterator rend() const { return t.rend(); }
  bool empty() const { return t.empty(); }
  size_type size() const { return t.size(); }
  size_type max_size() const { return t.max_size(); }
 
  // 返回用於key比較的函式
  key_compare key_comp() const { return t.key_comp(); }
 
  // 由於map的性質, value和key使用同一個比較函式, 實際上我們並不使用value比較函式
  value_compare value_comp() const { return value_compare(t.key_comp()); }
 
  // 注意: 這裡有一個常見的陷阱, 如果訪問的key不存在, 會新建立一個
  T& operator[](const key_type& k)
  {
    return (*((insert(value_type(k, T()))).first)).second;
  }
  // 過載了==和<操作符，後面會有實現
  friend bool operator== __STL_NULL_TMPL_ARGS (const map&, const map&);
  friend bool operator< __STL_NULL_TMPL_ARGS (const map&, const map&);
}


map的建構函式
map提供了一下的建構函式來初始化一個map

// 空建構函式，直接呼叫RBTree的空建構函式
map() : t(Compare()) {}
explicit map(const Compare& comp) : t(comp) {}
// 提供類似map<int,int> myMap(anotherMap.begin(),anotherMap.end())的初始化
template <class InputIterator>
map(InputIterator first, InputIterator last)
  : t(Compare()) { t.insert_unique(first, last); }
// 提供類似map<int,int> myMap(anotherMap.begin(),anotherMap.end(),less<int>)初始化
template <class InputIterator>
map(InputIterator first, InputIterator last, const Compare& comp)
  : t(comp) { t.insert_unique(first, last); }
// 提供類似map<int> maMap(anotherMap)的初始化
map(const map<Key, T, Compare, Alloc>& x) : t(x.t) {}
// 過載=操作符，賦值運算子
map<Key, T, Compare, Alloc>& operator=(const map<Key, T, Compare, Alloc>& x)
{
  t = x.t;
  return *this;
}
map的操作函式
insert
同set一樣，直接呼叫RBTree的插入函式即可，注意map不允許鍵值重複，所以呼叫的是insert_unique

// 對於相同的key, 只允許出現一次, bool標識
pair<iterator,bool> insert(const value_type& x) { return t.insert_unique(x); }
 
// 在position處
插入元素, 但是position僅僅是個提示, 如果給出的位置不能進行插入,
// STL會進行查詢, 這會導致很差的效率
iterator insert(iterator position, const value_type& x)
{
  return t.insert_unique(position, x);
}
// 將[first，last)區間內的元素插入到map中
template <class InputIterator>
void insert(InputIterator first, InputIterator last) {
  t.insert_unique(first, last);
}


erase

同set，直接呼叫即可// 擦除指定位置的元素, 會導致內部的紅黑樹重新排列
void erase(iterator position) { t.erase(position); }
 
// 會返回擦除元素的個數, 其實就是標識map內原來是否有指定的元素
size_type erase(const key_type& x) { return t.erase(x); }
void erase(iterator first, iterator last) { t.erase(first, last); }


clean

同set，直接呼叫即可

void clear() { t.clear(); }


find

// 查詢指定key的元素
iterator find(const key_type& x) { return t.find(x); }
const_iterator find(const key_type& x) const { return t.find(x); }
````


 
 
 
 
 過載運算子
上面介紹到map過載了[],==和<運算子，[]的實現已經介紹過，下面是==和<的實現

// 比較map直接是對其底層容器t的比較，直接呼叫RBTree的比較函式即可

template <class Key, class T, class Compare, class Alloc>
inline bool operator==(const map<Key, T, Compare, Alloc>& x,
                       const map<Key, T, Compare, Alloc>& y)
{
  return x.t == y.t;
}
template <class Key, class T, class Compare, class Alloc>
inline bool operator<(const map<Key, T, Compare, Alloc>& x,
                      const map<Key, T, Compare, Alloc>& y)
{
  return x.t < y.t;
}
其他操作函式
// 返回小於當前元素的第一個可插入的位置
iterator lower_bound(const key_type& x) {return t.lower_bound(x); }
const_iterator lower_bound(const key_type& x) const
{
  return t.lower_bound(x);
}
 
// 返回大於當前元素的第一個可插入的位置
iterator upper_bound(const key_type& x) {return t.upper_bound(x); }
const_iterator upper_bound(const key_type& x) const
{
  return t.upper_bound(x);
}
// 返回與指定鍵值相等的元素區間
pair<iterator,iterator> equal_range(const key_type& x)
{
  return t.equal_range(x);
}


multimap
multimap和map的關係就跟multiset和set的關係一樣，multimap允許鍵的值相同，因此在插入操作的時候用到insert_equal()，除此之外，基本上與map相同。

下面就僅僅列出不同的地方

template <class Key, class T, class Compare = less<Key>, class Alloc = alloc>
class multimap
{
  // ... 其他地方與map相同
  // 注意下面這些函式都呼叫的是insert_equal，而不是insert_unique
  template <class InputIterator>
  multimap(InputIterator first, InputIterator last)
    : t(Compare()) { t.insert_equal(first, last); }
 
  template <class InputIterator>
  multimap(InputIterator first, InputIterator last, const Compare& comp)
    : t(comp) { t.insert_equal(first, last); }
 
  // 插入元素, 注意, 插入的元素key允許重複
  iterator insert(const value_type& x) { return t.insert_equal(x); }
 
  // 在position處插入元素, 但是position僅僅是個提示, 如果給出的位置不能進行插入,
  // STL會進行查詢, 這會導致很差的效率
  iterator insert(iterator position, const value_type& x)
  {
    return t.insert_equal(position, x);
  }
  // 插入一個區間內的元素
  template <class InputIterator>
  void insert(InputIterator first, InputIterator last)
  {
    t.insert_equal(first, last);
  }
  // ...其餘地方和map相同
}


總結
總的來說，這四類容器僅僅只是在RBTree上進行了一層封裝，首先，set和map的區別就在於鍵和值是否相同，set中將值作為鍵，支援STL的提供的一些交集、並集和差集等運算；map的鍵和值不同，每個鍵都有自己的值，鍵不能重複，但是值可以重複。

multimap和multiset就在map和set的基礎上，使他們的鍵可以重複，除此之外基本等同。
--------------------- 
作者：zy20150613 
來源：CSDN 
原文：https://blog.csdn.net/zy20150613/article/details/78693579 
版權宣告：本文為博主原創文章，轉載請附上博文連結！

相關推薦

C++中map和set的使用與區別

set set是一種關聯式容器，其特性如下： set以RBTree作為底層容器 所得元素的只有key沒有value，value就是key 不允許出現鍵值重複 所有的元素都會被自動排序 不能通過迭代器來改變set的值，因為set的值就是鍵 針對這五點來說，

C++ STL中map和unordered_map的區別

map與unordered_map對比 map unordered_map 紅黑樹（屬於非嚴格二叉平衡搜尋樹）實現 雜湊表實現 有序 無序 —— 查詢時間複雜度為O(1

java中list和set的區別與聯絡

此文章是看別的大牛整理之後，自己學習進行消化後，對子自己的理解和得到的內容的一個總結。       介面Collection       Collection是java.util下的一個介面，它繼承的類是Iterable<E>。它是關於集合方面的一個跟介面，也就

C++中typename和class的區別

type .get true 能夠 class .... ray pla 依賴 在c++Template中很多地方都用到了typename與class這兩個關鍵字，而且好像可以替換，是不是這兩個關鍵字完全一樣呢? 相信學習C++的人對class這個關鍵字都非常明白，clas

C#中Monitor和Lock以及區別

能夠 program tor 試圖 tro 指定 object span () 原文地址：http://www.cnblogs.com/chengxingliang/p/3150731.html 　　Monitor對象 　　1.Monitor.Enter(object)方法

C#中Convert和parse的區別

處理 捕獲 用戶 整數 request 存在 query 轉換 中間 Convert.ToInt32()與int.Parse()的區別(1)這兩個方法的最大不同是它們對null值的處理方法： Convert.ToInt32(null)會返回0而不會產生任何異常，但int.P

C/C++中near和far的區別

語言 補充 detail net 計算機體系結構 偏移 單元 體系結構 all C/C++中near和far的區別 關鍵字near和far受目標計算機體系結構的影響。目前編程中使用不多。 near關鍵字創建一個指向可尋址內存低端部分的目標指針。這些

C#中virtual和abstract的區別

tool 保留 到你 variable var 入口 printf static write 解讀一 c# 中 Abstract和Virtual比較容易混淆，都與繼承有關，並且涉及override的使用。下面討論一下二者的區別： 一、Virtual方法（虛方法） 　　vir

JavaScript中Map和ForEach的區別

get 新的 create line 速度對比 圖片 技術分享 其中 原來 譯者按： 慣用Haskell的我更愛map。 原文: JavaScript?—?Map vs. ForEach - What’s the difference between Map and Fo

C#中Abstract和Virtual的區別

保留 一個 strac 虛擬 ati AI 靜態方法 void ride c# 中 Abstract和Virtual比較容易混淆，都與繼承有關，並且涉及override的使用。下面討論一下二者的區別： 一、Virtual方法（虛方法） 　　virtual 關鍵字用於在基

C++中指標和引用的區別、以及引用和取地址符&的區別

一. 指標和引用的區別 對於指標來說，它是一個地址，這個地址是一個數值，那麼就意味這個數值可以為0(空指標)，也可以為其他，即指標可以不指向任何東西。 而對於引用來說，他是一個外號，外號一定是“某個存在物體”的外號，所以引用不能為空，即不能存在空引用。例如我們給小明起了個外號：明明，那我們說

初夏小談：C++中“指標”和“引用“”的區別

1.引用只能繫結一個實體，而指標可以指向不同實體2.使用指標時要判空，而引用不需要因此更安全3.引用在定義時必須初始化，指標不做要求4.在sizeof中：引用結果是引用型別的大小，但指標始終是地址空間所佔位元組個數 void Size() { long long x =

C++中L和_T()之區別

字串前面加L表示該字串是Unicode字串。 _T是一個巨集，如果專案使用了Unicode字符集（定義了UNICODE巨集），則自動在字串前面加上L，否則字串不變。因此，Visual  C++裡邊定義字串的時候，用_T來保證相容性。VC支援ascii和unicode兩種字元型別，用_T可以

Java中List和set的區別

Java中List和set的區別 首先要知道 set和list都是集合介面 list ——其中的值允許重複，因為它是有自己的排序規則的資料結構 Set——其中的值不允許重複，無序的資料結構 知道了資料結構就得了解： List適合經常追加資料，插入，刪除資料。但隨機取數效率比較

LintCode 1484: The Most Frequent Word (練習C++ string, map和set)

原題如下： 1484. The Most Frequent word Give a string s witch represents the content of the novel, and then give a list indicating that the words do

C#中ref和out的區別

C#中的ref和out提供了值型別按引用進行傳遞的解決方案，當然引用型別也可以用ref和out修飾,但這樣已經失去了意義。因為引用資料型別本來就是傳遞的引用本身而非值的拷貝。ref和out關鍵字將告訴編譯器，現在傳遞的是引數的地址而不是引數本身，這和引用型別預設的傳遞方式是一樣的。 ref和

javascript中map和filter的區別

原生js中陣列可以直接通過map(),filter()函式來進行一次操作，他們分別是做一次統一對映，和一次過濾。說的更通俗一點，就是map函式之後，陣列元素個數不變，但是按照一定的條件轉換，陣列元素髮生了變化。filter函式之後，陣列元素個數可能發生了改變，但是陣列元素不會發生改變。 下面

C#中委託和事件的區別

大致來說，委託是一個類，該類內部維護著一個欄位，指向一個方法。事件可以被看作一個委託型別的變數，通過事件註冊、取消多個委託或方法。本篇分別通過委託和事件執行多個方法，從中體會兩者的區別。   □ 通過委託執行方法 class Program { st

關於C++中vector和set使用sort方法進行排序

C++中vector和set都是非常方便的容器， sort方法是algorithm標頭檔案裡的一個標準函式，能進行高效的排序，預設是按元素從小到大排序 將sort方法用到vector和set中能實現多種符合自己需求的排序 首先sort方法可以對靜態的陣列進行排序

c++中引用和指標的區別

指標和引用的區別： (1)當引用被建立時，它必須被初始化。而指標則可以在任何時候被初始化。 (2)一旦一個引用被初始化為指向一個物件，它就不能被改變為對另一個物件的引用。而指標則可以在任何時候指向另一個物件。 (3)不可能有NULL引用。必須確保引用是和一塊合法