C++標準庫知識點整理

本篇內容主要講解“C++標準庫知識點整理”，感興趣的朋友不妨來看看。本文介紹的方法操作簡單快捷，實用性強。下面就讓小編來帶大家學習“C++標準庫知識點整理”吧!

目錄

• C++模板
  

• C++標準庫
  

• C++ 面向對象類庫
  

• string
  

• 標準模板庫
  

• vector
  

• set

• list
  

• map
  

• queue
  

• priority_queue
  

• stack
  

• pair
  

• algorithm下的常用函數
  

C++模板

模板是泛型編程的基礎，泛型編程即以一種獨立于任何特定類型的方式編寫代碼

模板是創建泛型類或函數的藍圖或公式

可以使用模板來定義函數和類

//函數模板
template <typename type> ret-type func-name(parameter list)
{
   // 函數的主體
}

//類模板
template <class type> class class-name {
.
.
}

C++標準庫

①標準函數庫--繼承自C語言

I/O；字符串和字符處理；數學；時間、日期和本地化；動態分配；其他；寬字符函數

②面向對象類庫--類及相關函數的集合

C++ I/O；String類；數值類；STL容器類；STL算法；STL函數對象；STL迭代器；STL分配器；本地化庫；異常處理類；雜項支持庫

C++ 面向對象類庫

string

可以使用下標和迭代器訪問

string s1; //初始化字符串，空字符串，可變長
string s2 = "I am wenny"; //直接初始化
string s3 = string(6,'c'); //拷貝初始化
//cin>>s1;  //遇到空白停止讀取
cout<<s2;
str.c_str(); //將string型str使用c_str()變為字符數組，可以使用printf進行輸出
cout<<s2[0];  //可以使用下標引用
s2=s1;  //用s1代替s2
s1=s1+s2;  //連接s1和s2

getline(cin,s3); //獲取有空白符的一整行內容，按回車鍵結束輸入,不能輸入字符數組；輸入遺留在輸入緩沖的換行符消除
getline(cin,s3,'#')  //輸入一串字符（無論多少個回車鍵），只要是在‘#'之前的字符都會讀取并保存
s3.erase(10,8);  //刪除s3[10]開始的8個字符，時間復雜度O(n)
s3.insert(2,"bbb"); //在s3中下標為2的字符前插入字符串，時間復雜度O(n)
s3.insert(it,it2,it3);  //迭代器，表示串[it2,it3)將被插入在it的位置

cout<<s2.find("am",0);  //返回子串位置，第二個參數是查找起始位置,如果沒有找到返回string::npos；時間復雜度O(nm),n和m分別為str和str2的長度
s2.empty();
s2.size();
s2.substr(pos,len); //從pos號位開始，長度為len的子串，時間復雜度O(len)
s2.replace(pos,len,str2);  //從pos號為開始、長度為len的子串替換為str2；時間復雜度O(str.length())

標準模板庫

--實現多種流行和常用的算法和數據結構

幫助文件：c++API.chm（最后整理于2/26/2006）

cppreference-zh-20210212.chm

template <typename T>
inline void showset(set<T> v){
    for(typename set<T>::iterator it=v.begin();it!=v.end();it++)
        cout<<*it<<" ";
    cout<<endl;
}

vector

翻譯為向量--”變長數組“；可以不用初始化就必須指定大小的數組

可以通過下標和迭代器訪問

常見用途：1.儲存數據：元素個數不確定時 2.用鄰接表存儲圖

//初始化
vector<int> v1;
vector<vector<int>> v2;  //相當于變長二維數組
vector<int> v[100]; //相當于二維數組，第一維已經固定長度
vector<int> v3={1,2,3,4};
vector<string> v4(3,"hi");
vector<int> v5(4);  //默認初始化為0，字符串默認為空
//操作
v1.push_back(2); //向末尾添加對對象，時間復雜度O(1)
v1.pop_back(); //刪除尾部的對象，時間復雜度O(1)
v1.empty(); //返回bool值
v3.size();  //返回vector種元素的個數，時間復雜度O(1)
v1.clear(); //刪除所有元素，時間復雜度O(n)
v1.insert(v1.begin(),3); //插入一個或多個元素，時間復雜度O(n)
v1.erase(v1.begin());  //刪除一個或多個元素，時間復雜度O(n)
v1=v3;
//使用了迭代器的循環體，不要向迭代器所屬容器添加元素
cout<<v1[0]; //返回v種第0個位置上元素的引用
cout<<(v1==v5);  //相等當且僅當元素數量相同且對應位置的元素值都相同

set

翻譯為集合

與vector大致相同，但set中的元素有序且唯一；添加元素時自動排序，元素本來存在則動作不執行

只能通過迭代器訪問

常見用途：需要去重卻不方便直接開數組

set<int> s1={9,8,7,6,5,4};  //從小到大自動排序
showset(s1);
//cout<<s1[1]; //不能使用下標引用

set<string> s2={"hello","world","apple"};  //字典序排序
showset(s2);
    
s1.insert(9);  //已存在沒有插入動作，時間復雜度O(logn)
showset(s1);
s2.insert("banana"); //添加并排序
showset(s2);

set<int>::iterator it s1.find(2); //返回value對應的迭代器，時間復雜度O(logn)
s1.erase(); //參數是迭代器，時間復雜度為O(1);參數是value，時間復雜度是O(logn)

list

雙向鏈表

list<int> l1={6,7,3,4};
showlist(l1);
list<char> l2(5,'a');
showlist(l2);

l1.sort(); //list自己的排序函數，無參數
showlist(l1);

map

翻譯為映射

運用了hash地址映射的思想，即key-value；

將一個類型的變量映射至另一類型；

map的內部實現是一棵紅黑樹

可以通過下標和迭代器訪問

常見用途：建立字符串與整數之間的映射；判斷大整數或其它類型數據是否存在的題目，可以把map當bool數組用；

void showmap(map<string,int> v){
    for(map<string,int>::iterator it=v.begin();it!=v.end();it++)
        cout<<it->first<<" "<<it->second<<endl;  //first表示key，second表示value
    cout<<endl;
}

int main()
{
    map<string,int> m1;  //第一個參數是key，第二個參數是value
    m1["jojo"]=100;
    m1["kiki"]=99; //會以鍵從小到大的順序自動排序

    cout<<m1["jojo"]<<endl;  
    cout<<m1.count("wenny"); //判斷是否存在key，返回1或0
    cout<<m1["test"]<<endl; //不存在key，則顯示0，但會插入到map中
    
    showmap(m1);
    m1.erase("kiki");  //通過關鍵字刪除元素,時間復雜度O(logn)；直接刪除迭代器時間復雜度O(1)
    showmap(m1);
    m1.insert(pair<string,int>("harr",89));  //增加元素
    showmap(m1);
    m1.clear();  //清空元素
    m1.find(b);  //確定map中是否有string對象b的映射，若沒有函數返回m1.end()；時間復雜度O(logn)
    return 0;

}

queue

翻譯為隊列，實現先進先出

常見用途：實現廣度優先搜索

queue<int> q1;
q1.front(); //因為是限制性數據結構，只能通過front()來訪問隊首元素，back()來訪問隊尾元素
q1.back();
q1.push(1);
q1.pop();
q1.empty();
q1.size();

priority_queue

優先隊列，底層用堆實現；隊首元素一定是優先級最高的那個

常見用途：貪心問題；對dijkstra算法進行優化

priority_queue<int,vector<int>,greater<int>> q;  //從大到小排序，數字越小優先級越大
priority_queue<int,vector<int>,less<int>> q2;  //從小到大排序，數字越大優先級越大；默認
q.push(3);  //入隊，時間復雜度O(logn)
q.push(2);  
q.push(4);
cout<<q.top();  //獲得隊首元素，即堆頂元素
q.pop();  //出隊，時間復雜度O(logn)
cout<<q.top();
cout<<q.empty();
struct fru{
	string name;
	int price;
	bool operator < (const fru &b) const{
		return price>b.price;
	}
};
priority_queue<fru> q3; //按照重載的運算符<排序
fru f1,f2,f3;
f1.name = "peach";
f1.price = 3;
f2.name = "apple";
f2.price = 1;
q3.push(f1);
q3.push(f2);
cout<<endl<<q3.top().name<<" "<<q3.top().price;
struct cmp{
	bool operator () (const fru &a,const fru &b){
		return a.price>b.price;
	}
};
priority_queue<fru,vector<fru>,cmp> q4; //重寫排序規則
q4.push(f1);
q4.push(f2);
cout<<endl<<q4.top().name<<" "<<q4.top().price;

stack

棧，后進先出

常見用途：模擬實現一些遞歸

stack<int> s;
s.push(1);  //入棧，時間復雜度O(1)
s.push(2);
s.push(3);
s.pop();  //出棧，時間復雜度O(1)
cout<<s.top()<<endl;  //獲得棧頂元素，時間復雜度O(1)
cout<<s.empty()<<endl;
cout<<s.size()<<endl;

pair

可以看作一個內部有兩個元素的結構體

常見用途：用來代替二元結構及其構造函數，節省編碼時間；作為map的鍵值對進行插入

struct pair{
	typename first;
	typename second;
};
pair<string,int> p;
p.first = "haha";
p.second = 5;
p = make_pair("xixi",55);  //臨時構建一個pair
p = pair<string,int>("heihei",555);  //臨時構建一個pair
cout<<(p1>=p2);  //可以直接使用比較操作數

algorithm下的常用函數

int x=-1,y=2;
double a=0.1,b=0.2;
max(x,y);  //參數只能是兩個
min(a,b);
abs(x);  //x必須是整數
swap(x,y);  //交換x和y的值
int c[3]={1,2,3};
reverse(c,c+3);  //將數組指針在[it，it2）之間的元素或容器的迭代器在[it，it2）范圍內的元素進行反轉
int d[10]={1,2,3};
do{
    cout<<a[0]<<a[1]<<a[2]<<endl;
}while(next_permutation(d,d+3));  //函數給出一個序列在全排列中的下一個序列，到達全排列最后一個時會返回false
fill(d,d+2,5);  //把數組或容器的[it，it2)賦為某個相同的值
sort(d,d+3);  //默認遞增排序
//用在有序數組或容器中；時間復雜度O(log(last-first))；返回位置的指針或迭代器
lower_bound(d,d+3,2);  //尋找第一個大于等于val的元素位置
upper_bound(d,d+3,2);  //尋找第一個大于val的元素位置

到此，相信大家對“C++標準庫知識點整理”有了更深的了解，不妨來實際操作一番吧！這里是億速云網站，更多相關內容可以進入相關頻道進行查詢，關注我們，繼續學習！