2. 程式人生 > >c++ STL 學習筆記(pair 和 set)

c++ STL 學習筆記(pair 和 set)

阿新 • • 發佈：2019-01-14

STL pair

（1）pair 的定義

標頭檔案 <utility>
STL的標頭檔案中描述了一個看上去非常簡單的模版類pair，用來表示一個二元組或元素對，並提供了按照字典序對元素對進行大小比較運算子模版函式。

定義一個pair物件表示一個平面座標點：
例：

pair<double, double> p;
cin >> p.first >> p.second;

或者

pair <string,double> product1 ("tomatoes",3.25);

pair模版類需要兩個引數：首元素的資料型別和尾元素的資料型別。pair模版類物件有兩個成員：first和second，分別表示首元素和尾元素。

例：

pair<int,int>p1;
    pair<int,int>p2;
    cin>>p1.first>>p1.second;
    cin>>p2.first>>p2.second;
    cout<<'<'<<p1.first<<','<<p1.second<<'>'<<endl;
    cout<<'<'<<p2.first<<','<<p2.second<<'>'<<endl;

輸出結果
<p1.first,p1.second>
<p2.first,p2.second>

（2）pair 的比較

在<utility>中已經定義了pair上的六個比較運算子：<、>、<=、>=、==、!=，其規則是先比
較first，first相等時再比較second，這符合大多數應用的邏輯。當然，也可以通過過載這幾個運算子
來重新指定自⼰的比較邏輯。

例：

 if(p1>p2) cout<<"p1"<<endl;
    else if(p2>p1) cout<<"p2"<<endl;
    else cout<<"equal"<<endl;

（3）pair 的即時生成

除了直接定義一個pair物件外，如果需要即時生成一個pair物件，也可以呼叫在<utility>中定
義的一個模版函式：make_pair。make_pair需要兩個引數，分別為元素對的首元素和尾元素。
例：

pair <string,double> product3;
product3 = make_pair ("shoes",20.0);
cout <<"The price of "<< product3.first <<" is $"<< product3.second <<"\n";

輸出結果：
The price of shoes is $ 20.0

注：
一般make_pair都使用在需要pair做引數的位置，可以直接呼叫make_pair生成pair物件。
另一個使用的方面就是pair可以接受隱式的型別轉換，這樣可以獲得更高的靈活度。但是這樣會出現如下問題：
例如有如下兩個定義：

   std::pair<int, float>(1, 1.1);
    	std::make_pair(1, 1.1);

其中第一個的second變數是float型別，而make_pair函式會將sec新增連結描述ond變數都轉換成double型別。
這個問題在程式設計是需要引起注意。

STL set

引用自 c++set 用法詳解

（1）set 的定義：

標頭檔案<set>
關於set，必須說明的是set關聯式容器。set作為一個容器也是用來儲存同一資料型別的資料型別，並且能從一個數據集合中取出資料，在set中每個元素的值都唯一，而且系統能根據元素的值自動進行排序。應該注意的是set中數元素的值不能直接被改變。C++ STL中標準關聯容器set, multiset, map, multimap內部採用的就是一種非常高效的平衡檢索二叉樹：紅黑樹，也成為RB樹(Red-Black Tree)。RB樹的統計效能要好於一般平衡二叉樹，所以被STL選擇作為了關聯容器的內部結構。
定義一個set物件：

set<int> s;
set<double> ss;

（2）set 的基本操作：

s.begin()	    // 返回指向第一個元素的迭代器
s.clear()	 	// 清除所有元素
s.count() 	 	// 返回某個值元素的個數
s.empty()	 	// 如果集合為空，返回true(真）
s.end()		 	// 返回指向最後一個元素之後的迭代器，不是最後一個元素
s.equal_range()  // 返回集合中與給定值相等的上下限的兩個迭代器
s.erase() 		// 刪除集合中的元素
s.find() 		// 返回一個指向被查詢到元素的迭代器
s.get_allocator() // 返回集合的分配器
s.insert() 		 // 在集合中插入元素
s.lower_bound()  // 返回指向大於（或等於）某值的第一個元素的迭代器
s.key_comp() 	// 返回一個用於元素間值比較的函式
s.max_size() 	// 返回集合能容納的元素的最大限值
s.rbegin()		 // 返回指向集合中最後一個元素的反向迭代器
s.rend()		 // 返回指向集合中第一個元素的反向迭代器
s.size() 		// 集合中元素的數目
s.swap()		 // 交換兩個集合變數
s.upper_bound() 	 // 返回大於某個值元素的迭代器
s.value_comp() 	// 返回一個用於比較元素間的值的函式

例：

#include <iostream>
#include <set>
 
using namespace std;
 set<int>s;
    s.insert(1);
    s.insert(2);
    s.insert(4);
    s.insert(0);
    cout<<"set 的 size 值為 ："<<s.size()<<endl;
    cout<<"set 的 maxsize的值為 ："<<s.max_size()<<endl;
    cout<<"set 中的第一個元素是 ："<<*s.begin()<<endl;
     cout<<"set 中的最後一個元素是:"<<*s.end()<<endl;
     if(s.empty())
     {
         cout<<"set 為空 ！！！"<<endl;
     }
     else cout<<"set 的 size 值為 ："<<s.size()<<endl;
     s.clear();
     if(s.empty())
     {
         cout<<"set 為空 ！！！"<<endl;
     }
     else cout<<"set 的 size 值為 ："<<s.size()<<endl;
     cout<<"set 的 size 值為 ："<<s.size()<<endl;
     cout<<"set 的 maxsize的值為 ："<<s.max_size()<<endl;
     return 0;
}

執行結果
set 的 size 值為 ：4
set 的 maxsize的值為 ：214748364
set 中的第一個元素是 ：0
set 中的最後一個元素是:4
set 的 size 值為 ：4
set 為空 ！！！
set 的 size 值為 ：0
set 的 maxsize的值為 ：214748364

rbegin()與rend()

迭代器
反向迭代器

反向迭代器是一種反向遍歷容器的迭代器。也就是，從最後一個元素到第一個元素遍歷容器。反向迭代器將自增（和自減）的含義反過來了：對於反向迭代器，++ 運算將訪問前一個元素，而 – 運算則訪問下一個元素。

.begin() 返回一個迭代器，它指向容器c的第一個元素
.end() 返回一個迭代器，它指向容器c的最後一個元素的下一個位置
.rbegin() 返回一個逆序迭代器，它指向容器c的最後一個元素
.rend() 返回一個逆序迭代器，它指向容器c的第一個元素前面的位置

反向迭代器用於表示範圍，而所表示的範圍是不對稱的，這個事實可推匯出一個重要的結論：使用普通的迭代器對反向迭代器進行初始化或賦值時，所得到的迭代器並不是指向原迭代器所指向的元素。

set的遍歷

#include<cstdio>  
#include<set>  
using namespace std;  
int main()  
{  
    set<int>s;  
    s.insert(3);   
    s.insert(1);  
    s.insert(2);  
    s.insert(1);  
    set<int>::iterator it;              
    for(it=s.begin();it!=s.end();it++)  //使用迭代器進行遍歷   
    {  
        printf("%d\n",*it);  
    }  
    return 0;  
}  
//輸出結果 ： 1 2 3     一共插入了4個數，但是集合中只有3個數並且是有序的，可見之前說過的set集合的兩個特點，有序和不重複。

小結： 還要注意begin() 和 end()函式是不檢查set是否為空的，使用前最好使用empty()檢驗一下set是否為空.

count()

用來查詢set中某個某個鍵值出現的次數。這個函式在set並不是很實用，因為一個鍵值在set只可能出現0或1次，這樣就變成了判斷某一鍵值是否在set出現過了。
例：

#include <iostream>
#include <set>
 
using namespace std;
 
int main(){
     set<int> s;
     s.insert(1);
     s.insert(2);
     s.insert(3);
     s.insert(1);
     cout<<"set 中 1 出現的次數是 ："<<s.count(1)<<endl;
     cout<<"set 中 4 出現的次數是 ："<<s.count(4)<<endl;
     return 0;
}

結果
set 中 1 出現的次數是 ： 1
set 中 4 出現的次數是 ： 0

equal_range()

返回一對定位器，分別表示第一個大於或等於給定關鍵值的元素和 第一個大於給定關鍵值的元素，這個返回值是一個pair型別，如果這一對定位器中哪個返回失敗，就會等於end()的值。
例：

#include <iostream>
#include <set>
using namespace std;

int main()
{
    set<int>s;
    set<int>::iterator ter;
    for(int i=1;i<5;i++)
        s.insert(i);
     pair<set<int>::const_iterator,set<int>::const_iterator> pr;
     pr = s.equal_range(3);
     cout<<"第一個大於等於 3 的數是 ："<<*pr.first<<endl;
     cout<<"第一個大於 3的數是 ： "<<*pr.second<<endl;
    return 0;
}

結果
第一個大於等於 3 的數是 ： 3
第一個大於 3的數是 ： 4

erase()

erase(iterator) ,刪除定位器iterator指向的值
erase(first,second),刪除定位器first和second之間的值
erase(key_value),刪除鍵值key_value的值
例：

#include <iostream>
#include <set>

using namespace std;

int main(){
     set<int> s;
     set<int>::const_iterator iter;
     set<int>::iterator first;
     set<int>::iterator second;
     for(int i = 1 ; i <= 10 ; ++i)
     {
         s.insert(i);
     }
     for(iter = s.begin() ; iter != s.end() ; ++iter)
     {
         cout<<*iter<<" ";
     }
     cout<<endl;
     //第一種刪除
     s.erase(s.begin());
     //第二種刪除
     first=s.begin();
     second=s.begin();
     second++;
     second++;
     s.erase(first,second);
     //第三種刪除
     s.erase(8);
    cout<<"刪除後 set 中元素是 ："<<endl;
     for(iter = s.begin() ; iter != s.end() ; ++iter)
     {
         cout<<*iter<<" ";
     }
     cout<<endl;
    return 0;
}

結果：
1 2 3 4 5 6 7 8 9 10
刪除後 set 中元素是 ：
4 5 6 7 9 10

小結：set中的刪除操作是不進行任何的錯誤檢查的，比如定位器的是否合法等等，所以用的時候自己一定要注意。

insert()

insert(key_value)
將key_value插入到set中 ，返回值是pair<set::iterator,bool>，bool標誌著插入是否成功，而iterator代表插入的位置，若key_value已經在set中，則iterator表示的key_value在set中的位置。
inset(first,second)
將定位器first到second之間的元素插入到set中，返回值是void.
例：

#include <iostream>
#include <set>

using namespace std;

int main()
{
     int a[] = {1,2,3};
     int t;
     set<int> s;
     set<int>::iterator iter;
     s.insert(a,a+3);
     for(iter = s.begin() ; iter != s.end() ; ++iter)
     {
         cout<<*iter<<" ";
     }
     cout<<endl;
     pair<set<int>::iterator,bool> pr;
     cin>>t;
     pr = s.insert(t);
     if(!pr.second)
     {
         cout<<"error"<<endl;
     }
     for(iter = s.begin() ; iter != s.end() ; ++iter)
     {
         cout<<*iter<<" ";
     }
     cout<<endl;
     return 0;
}

lower_bound&& upper_bound

lower_bound(key_value) ，返回第一個大於等於key_value的定位器
upper_bound(key_value)，返回最後一個大於等於key_value的定位器
例：


#include <iostream>
#include <set>
 
using namespace std;
 
int main()
{
     set<int> s;
     s.insert(1);
     s.insert(3);
     s.insert(4);
     cout<<*s.lower_bound(2)<<endl;
     cout<<*s.lower_bound(3)<<endl;
     cout<<*s.upper_bound(3)<<endl;
     return 0;
}

結果：
3
3
4

.find()

find(Key)的功能是返回鍵值為Key的元素的位置，返回值是迭代器型別
例

#include <iostream>
#include <set>
using namespace std;

int main()
{
    set<int>s;
    for(int i=0;i<10;i++)
        s.insert(i);
    set<int>::iterator it1=s.find(4);
    set<int>::iterator it2=s.find(11);
    if(it1!=s.end())
        cout<<*(it1)<<endl;
    else cout<<"error"<<endl;
    if(it2!=s.end())
        cout<<*(it2)<<endl;
    else cout<<"error"<<endl;
    return 0;
}

結果
4
error

.swap()

進行兩個集合的交換
例

#include <iostream>
#include <set>
using namespace std;

int main()
{
    set<int>s1;
    set<int>s2;
    for(int i=0;i<10;i++)
        s1.insert(i);
    for(int i=10;i<15;i++)
        s2.insert(i);
    cout<<"s1:";
    for(set<int>::iterator it =s1.begin();it!=s1.end();it++)
        cout<<*(it)<<" ";
    cout<<endl;
    cout<<"s2:";
    for(set<int>::iterator it =s2.begin();it!=s2.end();it++)
        cout<<*(it)<<" ";
    cout<<endl;
    s1.swap(s2);//進行交換
    cout<<"s1:";
    for(set<int>::iterator it =s1.begin();it!=s1.end();it++)
        cout<<*(it)<<" ";
    cout<<endl;
    cout<<"s2:";
    for(set<int>::iterator it =s2.begin();it!=s2.end();it++)
        cout<<*(it)<<" ";
    cout<<endl;
    return 0;
}

結果
s1:0 1 2 3 4 5 6 7 8 9
s2:10 11 12 13 14
s1:10 11 12 13 14
s2:0 1 2 3 4 5 6 7 8 9

key_comp().value_comp()

在set中兩種函式使用方法相同
不過返回型別不同
key_comp()為key_compare型
value_comp()為value_compare型
例

#include <iostream>
#include <set>
#include <algorithm>
using namespace std;
int main()
{
    set<double>s;
    for(int i=0;i<10;i++)
        s.insert(i);
    set<double>::key_compare kc1=s.key_comp();
    cout<<"s1:"<<endl;
    for(set<double>::iterator it=s.begin();it!=s.end();it++)
      {
          cout<<*(it)<<" ";
          if(kc1(7,*(it))==true) break;
      }
    cout<<endl;
    return 0;
}

結果
s1:
0 1 2 3 4 5 6 7 8

自定義比較函式

(1)元素不是結構體：

例
//自定義比較函式myComp,過載“（）”操作符

struct myComp  
{  
    bool operator()(const your_type &a,const your_type &b)  
    {  
        return a.data-b.data>0;  
    }  
}  
set<int,myComp>s;  
......  
set<int,myComp>::iterator it;
(2)如果元素是結構體，可以直接將比較函式寫在結構體內。

例

struct Info  
{  
    string name;  
    float score;  
    //過載“<”操作符，自定義排序規則  
    bool operator < (const Info &a) const  
    {  
        //按score從大到小排列  
        return a.score<score;  
    }  
}  
set<Info> s;  
......  
set<Info>::iterator it;

例

#include<stdio.h>  
#include<set>  
#include<string>  
using namespace std;  
struct People  
{  
    string name;  
    int age;  
    bool operator <(const People p) const  //運算子過載   
    {  
        return age<p.age;       //按照年齡由小到大進行排序   
    }  
};   
int main()  
{     
    set<People>s;  
    s.insert((People){"張三",14});  
    s.insert((People){"李四",16});  
    s.insert((People){"王二麻子",10});  
    set<People>::iterator it;              
    for(it=s.begin();it!=s.end();it++)  //使用迭代器進行遍歷   
    {  
        printf("姓名：%s 年齡：%d\n",(*it).name.c_str(),(*it).age);  
    }  
    return 0;  
}

結果
姓名：王二麻子 年齡：10
姓名：張三 年齡：14
姓名：李四 年齡：16

multiset是另一種型別的容器，其關鍵詞與資料檔案是同一個值，與set不同，其可包含重複的元素，其用法與set相似。

相關推薦

c++ STL 學習筆記(pair 和 set)

STL pair （1）pair 的定義 標頭檔案 <utility> STL的標頭檔案中描述了一個看上去非常簡單的模版類pair，用來表示一個二元組或元素對，並提供了按照字典序對元素對進行大小比較運算子模版函式。 定義一個pair物件表示一個平面座標點： 例：

C++|STL學習筆記-對STL中關聯容器map的進一步認識

關聯容器map key + value 的值 關聯容器 = 有序容器(紅黑樹) + 無序容器（散列表） + hash_map 有序容器中： map的鍵值是不允許重複的 multimap的鍵值是允許重複的 set是一個集合，鍵值=實值，就是隻包含一個值，既是鍵值也是實值，不允許重複 mul

C++|STL學習筆記-map的基本操作（插入，刪除，遍歷，大到小輸出）【仿大佬寫法】

首先的程式碼是插入，刪除，遍歷 執行截圖如下： 原始碼如下： #include <map> #include <iostream> #include <algorithm> using namespace std; typedef pair

C++|STL學習筆記-map的屬性（大小以及是否存在）

目錄 1.size()的用法 map的property map屬性 1.沒有容量； 2.得到元素的個數size() 這裡給出呼叫他size()的例子，原始碼如下： /*****

c++ STL 學習筆記(map )

關於map 在STL的標頭檔案中<map>中定義了模版類map和multimap，用有序二叉樹表儲存型別為 pair<const Key, T>的元素對序列。序列中的元素以const Key部分作為標識，map中所有元素的Key 值必須是唯一的，multimap則

C++ STL學習筆記四 list雙向連結串列容器

/* * ******************************************** *   list雙向連結串列容器的基礎說明： ******************************************** * * list雙向連結串列容器採用雙向

【C++ STL學習之五】容器set和multiset

一、set和multiset基礎 set和multiset會根據特定的排序準則，自動將元素進行排序。不同的是後者允許元素重複而前者不允許。 需要包含標頭檔案： #include <set> set和multiset都是定義在std空間裡的類模板： templ

C++ Primer 學習筆記_5_變量和基本類型（續2）

key 情況 boa 類和對象 類定義 優點 splay 查看 變量定義  變量和基本類型 七、枚舉 枚舉不但定義了整數常量集，並且還把它們聚集成組。 枚舉與簡單的const常量相比孰優孰劣， 通過以下一段代

C++ Primer 學習筆記與思考_7 void和void*指針的使用方法

能夠 amp space turn begin member use mem urn (一)void的含義 void的字面意思是“無類型”，void差點兒僅僅有“凝視”和限制程序的作用，由於從來沒有人會定義一個void變量，讓我們試著來定義： void a;

C語言學習筆記 (003) - C/C++中的實參和形參(轉)

變化 避免 影響 學習筆記 ++ nbsp 過去 情況 真的 今天突然看到一道關於形參和實參的題，我居然不求甚解。藐視過去在我的腦海裏只有一個參數的概念，對於形參和實參的區別還真的不知道，作為學習了幾年C++的人來說，真的深深感覺對不起自己對不起C++老師 T。T 我

C語言學習筆記-1.(資料表示和輸出)

C裡面的資料表示和輸出很重要.所以在此記下一些平時會用的東西. 1.系統自帶輸出八進位制和十六進位制(整數): 輸出八進位制:%o             輸出帶字首的八進位制:%#o 輸出十六進位制:%x 

C# in Depth學習筆記-排序和過濾

1.2 排序和過濾 本節不會改變 Product 型別，我們會使用示例的產品列表，並按名稱排序，然後找出最貴的產品。 每個任務都不難，但我們可以看到它到底能簡化到什麼程度。 1.2.1 按名稱對產品進行排序 以特定順序顯示一個列表的最簡單方式就是先將列表排好序，再遍歷並顯示其中的項。 在.NET

C++ 學習筆記 變數和基本型別（一）

C++ 學習筆記 一、變數和基本型別概述 型別是所有程式的基礎。型別告訴我們資料代表什麼意思以及可以對資料執行哪些操作。 c++基本型別： 字元型 整型 浮點型 c++ 還提供了可用於自定義資料型別的機制，標準庫正式利用了這些機制定義了許多更復雜的型別，比如可變長字串string 和vector等。此外，

C語言學習筆記---《C陷阱和缺陷》字元和字串

C語言中的單引號和雙引號含義迥異，在某些情況下如果把二者弄混，編譯器並不會檢測報錯，從而在執行時產生難以預料的結果。 用單引號引起來的一個字元實際上代表一個整數，整數值對應於該字元在編譯器採用的字符集中的序列值。因此對於採用ASCII字符集的編譯器而言，'a'的含義與014

C語言學習筆記---C專家程式設計 什麼時候陣列和指標相同

 什麼時候陣列和指標是相同的： 規則1：表示式中的陣列名（與申明不同）被編譯器當作指向該陣列第一個元素的指標 規則2：下標總是與指標的偏移量相同 規則3：在函式引數的宣告中，陣列名被編譯器當作指向該陣列第一個元素的指標 規則1的例外情況： 1、陣列作為sizeo

C++STL學習——Set集合

簡單介紹 集合(Set)是一種包含已排序物件的關聯容器，其中所包含的元素是唯一的，集合中的元素按一定的順序排列。元素插入過程是按排序規則插入，所以不能指定插入位置。 set採用紅黑樹變體的資料結構實現，紅黑樹屬於平衡二叉樹。在插入操作和刪除操作上比vector快。 s

C語言學習筆記：指標函式和函式指標的淺析

#include "stdio.h" #include "stdlib.h" #include <string.h> /*--------------指標函式---------------*/  int *f(int a,int b ){        int

c++學習筆記之類和物件的進階

此程式的作用是統計銷售額和商品的平均售價，涉及到的知識有靜態成員函式和初始化和應用 #include<iostream> using namespace std; class product { public: product(int m,int q,float p):num(

C++11學習筆記：std::move和std::forward原始碼分析

std::move和std::forward是C++0x中新增的標準庫函式，分別用於實現移動語義和完美轉發。下面讓我們分析一下這兩個函式在gcc4.6中的具體實現。 預備知識 引用摺疊規則： X& + & => X& X&& +

C語言學習筆記--小端模式和大端模式

一、概念：     大端（儲存）模式：是指一個數據的低位位元組序的內容放在高地址處，高位位元組序存的內容放在低地址處。     小端（儲存）模式：是指一個數據的低位位元組序內容存放在低地址處，高位位元組序的內容存放在高地址處。 二、程式碼 #include