本文共 7985 字，大约阅读时间需要 26 分钟。

STL

C++面向对象和泛型编程的思想，目的就是复用性的提升

STL（Standard Template Library，标准模板库） STL从广义上分为：容器（container）算法（algorithm）迭代器（iterator） 容器和算法之间通过迭代器进行无缝连接 STL六大组件： 容器：各种数据结构 算法：各种常见的算法 迭代器：扮演了容器和算法之间的胶合剂 仿函数：行为类似函数，可作为算法的某种策略 适配器：一种用来修饰容器或者仿函数或者迭代器接口的东西 空间适配器：负责空间的配置与管理

1. STL初识

容器：vector

算法：for_each 迭代器：vector::iterator

vector
   
     v;	for(int i=0;i<10;i++){   		v.push_back(i);	//插入数据 	}	for(vector
    
     ::iterator it=v.begin();it!=v.end();it++){   	//遍历容器 		cout<<*it<
    
   

vector嵌套：

vector< vector
   
     > v;	vector
    
      v1;	vector
     
       v2;	vector
      
        v3;	for(int i=0;i<4;i++){   		v1.push_back(i);		v2.push_back(i+1);		v3.push_back(i+2);	}	v.push_back(v1);	v.push_back(v2);	v.push_back(v3);	for(vector< vector
       
         >::iterator it=v.begin();it!=v.end();it++){   		for(vector
        
         ::iterator vit=(*it).begin;vit!=(*it).end;vit++){ cout<<*vit<
        
       
      
     
    
   

相当于二维数组

2. string容器

2.1 构造

string(); //创建一个空字符串，例如：string str； string(const char* s); //使用字符串s初始化 string(const string& str); //使用一个string对象初始化另一个string对象 string(int n,char c); //使用n个字符c初始化；

string s1;	//创建空字符串 	const char* s2="hello world";	string s3(s2);	//调用拷贝构造函数 	string s4(10,'a');	//10个字符a赋值给s4

2.2 赋值

string s1="hello world";	//字符s1赋值 	string s2=s1;	//字符s1赋值给s2 	string s3='a';	//字符值赋给当前字符串 	string s4;	s4.assign("hello world");	//字符串s赋值给当前字符 	string s5;	s5.assign("hello world",5);	//把字符串前5个字符赋值给当前字符串 	string s6;			s6.assign(s5);		//把字符串s赋值给当前字符串 	string s7;	s7.assign(5,'x');	//用n个字符c赋值给当前字符串

2.3 拼接

string s1="我";	s1+="爱玩";	string s2="游戏";	s1+=s2;	string s3="I";	s3.append(" love ");	//把字符串s接到当前字符串结尾 	s3.append("game ab",4);	//把字符串s前n个字符连接到当前字符串结尾 	s3.append(s2);		//将字符串s连接到当前字符串结尾 	s3.append(s2,4,3);	//将字符串s中从pos开始的n个字符连接到当前字符串结尾，s.append(字符串，起始位置，字符数)

2.4 查找与替换

string s1="abcdefgde";	int pos=s1.find("de");	//查找起始位置	s1.replace(1,3,"aaaaa");	//s.replace(起始位置，替换数目，替换字符串)

总结：

find查找是从左往右，rfind从右往左 find找到字符串后返回查找的第一个字符位置，找不到返回-1 replace在替换时，要指定从哪个位置起，多少个字符，替换成什么

2.5 插入和删除

string s1="hello";	s1.insert(1,"he");	//在指定位置插入字符串 	s1.insert(4,5,'c');	//在指定位置插入指定数目字符 	s1.erase(5);	//从指定位置开始删除字符串	s1.erase(3,2);	//从指定位置删除指定数目字符

总结：

插入： s.insert(指定位置，字符串(字符))； s.insert(指定位置，指定数目，指定字符)； 删除： s.erase(指定位置，指定数目(可省略))；

2.6 子串获取

string s1="abcdef";	string s2=s1.substr(2,3);	//从字符串s指定位置开始截取指定数目字符

3. vector容器

3.1 基本概念

功能：与数组相似，单端数组 与数组区别：vector可以动态扩展

3.2 构造

vector
   
     v1;	for(int i=0;i<10;i++){   		v1.push_back(i); 	}	vector
    
      v2(v1.begin(),v1.end());	//将区间begin()到end()的值赋给v2	vector
     
       v3(10,100);	//将指定数目的值赋值给v3	vector
      
        v4(v3);	//拷贝构造
      
     
    
   

3.3 赋值

vector
   
     v2;	v2=v1;	vector
    
      v3;	v3.assign(v1.begin(),v1.end());	//将begin()到end()的值赋值给v3 	vector
     
       v4;	v4.assign(10,100);
     
    
   

3.4 容量和大小

v1.empty();	//判断容器是否为空	v1.capacity() ;	//容器的容量	v1.size();	//返回容器中元素个数	v1.resize(6);	//重新指定容器的长度，若容器变长，则用默认值填充新位置					//若容器变短，则末尾超出容器长度的元素被删除	v1.resize(6,8); //重新指定容器的长度，若容器变长，则用指定值填充新位置					//若容器变短，则末尾超出容器长度的元素被删除

3.5 插入和删除

v1.push_back(ele); //在尾部插入元素ele	v1.pop_back();	//删除最后一个元素	v1.insert(const_iterator pos,ele);	//迭代器指向位置pos插入元素ele	v1.insert(const_iterator pos,int count,ele);	//迭代器指向位置pos插入count个元素ele	v1.erase(const_iterator pos);	//删除迭代器指向的元素	v1.erase(const_iterator start,const_iterator end);	//删除迭代器从start到end之间的所有元素	v1.clear();	//删除容器中所有元素

3.6 数据存取

v1.at(int idx);	//返回索引idx所指的数据	cout<

4. deque容器

功能：双端数组，可以对头端进行插入删除操作

deque与vector区别： vector对于头部的插入删除操作效率低，数据量越大，效率越低 deque相对而言，对头部的插入删除速度比vector快 vector访问元素的速度会比deque快

4.1 构造

deque
   
     d1;	for(int i=0;i<10;i++){   		d1.push_back(i); 	}	deque
    
      d2(d1.begin(),d1.end());	//将区间begin()到end()的值赋给d2	deque
     
       d3(10,100);	//将指定数目的值赋值给d3	deque
      
        d4(v3);	//拷贝构造
      
     
    
   

4.2 赋值

deque
   
     d2;	d2=d1;	deque
    
      d3;	d3.assign(d1.begin(),d1.end());	//将begin()到end()的值赋值给d3 	deque
     
       d4;	d4.assign(10,100);
     
    
   

4.3 deque容量和大小

d1.empty();	//判断容器是否为空	d1.capacity() ;	//容器的容量	d1.size();	//返回容器中元素个数	d1.resize(6);	//重新指定容器的长度，若容器变长，则用默认值填充新位置					//若容器变短，则末尾超出容器长度的元素被删除	d1.resize(6,8); //重新指定容器的长度，若容器变长，则用指定值填充新位置					//若容器变短，则末尾超出容器长度的元素被删除

4.4 插入和删除

deque
   
     d;	d.push_back(elem);		//在容器尾部添加一个数据 	d.push_front(elem);		//在容器头部插入一个数据 	d.pop_back();			//删除容器最后一个数据 	d.pop_front();			//删除容器第一个数据 	d.insert(pos,elem);		//在pos位置插入一个elem元素的拷贝，返回新数据的位置 	d.insert(pos,n,elem);	//在pos位置插入n个elem数据，无返回值 	d.insert(pos,beg,end);	//在pos位置插入[beg，end)区间的数据，无返回值 	d.clear();				//清空所有数据 	d.erase(beg,end);		//删除[beg，end)区间的数据，返回下一个数据的位置 	d.erase(pos);			//删除pos位置的数据，返回下一个数据的位置
   

4.5 数据存取

d1.at(int idx);	//返回索引idx所指的数据	cout<

5. stack容器

概念：stack是一种先进后厨的数据结构

stack
   
     s;	//构造栈	s.push(elem);	//向栈顶添加元素	s.pop();		//从栈顶移除第一个元素 	s.top();		//返回栈顶元素 	s.empty();		//判断栈是否为空 	s.size(); 		//返回栈的大小
   

6. queue容器

概念：queue是一种先进先出的数据结构

queue
   
     q;	//构造队列 	q.push(elem);	//向队尾添加元素		q.pop();		//从对头移除第一个元素 	q.back();		//返回最后一个元素 	q.front();		//返回第一个元素 	q.empty();		//判断队列是否为空 	q.size();		//返回队列大小
   

7. list容器

功能：将数据进行链式存储

STL中的链表是一个双向循环链表 由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器 list的有点： 采用动态存储分配，不会造成内存浪费和溢出 链表执行插入和删除操作十分方便，修改指针即可，不需要大量移动元素 list的缺点： 链表灵活，但是空间和时间额外耗费较大

7.1 构造

list
   
     l1;	for(int i=0;i<10;i++){   		l1.push_back(i); 	}	list
    
      l2(l1.begin(),l1.end());	//将区间begin()到end()的值赋给l2	list
     
       l3(10,100);	//将指定数目的值赋值给l3	list
      
        l4(l3);	//拷贝构造
      
     
    
   

7.2 赋值

list
   
     l2;	l2=l1;	list
    
      l3;	l3.assign(l1.begin(),l1.end());	//将begin()到end()的值赋值给l3 	list
     
       l4;	l4.assign(10,100);
     
    
   

7.3 大小

l1.empty();	//判断容器是否为空	l1.size();	//返回容器中元素个数	l1.resize(6);	//重新指定容器的长度，若容器变长，则用默认值填充新位置					//若容器变短，则末尾超出容器长度的元素被删除	l1.resize(6,8); //重新指定容器的长度，若容器变长，则用指定值填充新位置					//若容器变短，则末尾超出容器长度的元素被删除

7.3 插入和删除

list
   
     l;	l.push_back(elem);		//在容器尾部添加一个数据 	l.push_front(elem);		//在容器头部插入一个数据 	l.pop_back();			//删除容器最后一个数据 	l.pop_front();			//删除容器第一个数据 	l.insert(pos,elem);		//在pos位置插入一个elem元素的拷贝，返回新数据的位置 	l.insert(pos,n,elem);	//在pos位置插入n个elem数据，无返回值 	l.insert(pos,beg,end);	//在pos位置插入[beg，end)区间的数据，无返回值 	l.clear();				//清空所有数据 	l.erase(beg,end);		//删除[beg，end)区间的数据，返回下一个数据的位置 	l.erase(pos);			//删除pos位置的数据，返回下一个数据的位置 	l.remove(elem);			//删除容器中所有与elem值匹配的元素
   

7.4 数据存取

l.front();	//返回第一个元素	l.back();	//返回最后一个元素

7.5 反转与排序

l.reverse();	//反转链表	l.sort();		//链表排序

8. set/multiset 容器

set基本概念：所有元素都会在插入时自动排序

set与multiset区别： set不允许容器中有重复的元素 multiset允许容器中有重复的元素

8.1 构造和赋值

set
   
     s;	s.insert(elem);		//插入数据elem
   

8.2 大小和交换

s.empty();	//判断容器是否为空	s.size();	//返回容器中元素个数	s.swap(s1);	//交换两个容器的元素

8.3 插入和删除

s.insert(elem);			//在容器中插入元素	s.clear();				//清空所有数据 	s.erase(beg,end);		//删除[beg，end)区间的数据，返回下一个数据的位置 	s.erase(pos);			//删除pos迭代器所指位置的数据，返回下一个数据的位置 	s.erase(elem);			//删除容器中elem值的元素

8.4 查找和统计

s.find(key);		//查找key元素是否存在，返回该元素的迭代器	s.count(key);		//统计key元素的个数

9. pair容器

功能描述：成对出现的数据，利用pair可以返回两个数据

创建方式： pair<type,type> p(value1,value2); pair<type,type> p=make_pair(value1,value2);

pair
   
     p1("Tom",18);	pair
    
      p2=make_pair("Jerry",18);	cout<
     
      <<" "<
      
       <
      
     
    
   

10. map容器

简介：

map容器中所有元素都是pair pair中第一个元素为key（键值），第二个元素为value（实值） 所有元素都会根据元素的键值自动排序 优点： 可以根据key值快速找到value map和multimap区别： map不允许容器中有重复的key值元素 multimap中允许荣有重复的key值元素

10.1 构造

map
   
     m;	m.insert(pair
    
     (1,10));	m.insert(pair
     
      (2,20));	m.insert(pair
      
       (3,30));	m.insert(pair
       
        (4,40));	for(map
        
         ::iterator it=m.begin();it!=m.end();it++){ cout<<(*it).first<<" "<<(*it).second<
        
       
      
     
    
   

10.2 大小和交换

m.empty();	//判断容器是否为空	m.size();	//返回容器中元素个数	m.swap(s1);	//交换两个容器的元素

10.3 插入和删除

m.insert(elem);		//在容器中插入元素	m.clear();			//清除所有元素 	m.erase(pos);		//删除pos迭代器所指的元素，返回下一个元素的迭代器 	m.erase(beg,end);	//删除区间[beg，end)的所有元素，返回下一个元素的迭代器 	m.erase(key); 		//删除容器中值为key的元素

四种插入方式：

m.insert(pair
   
    (1,10));	m.insert(make_pair(2,20));	m.insert(map
    
     ::value_type(3,30));	m[4]=40;
    
   

10.4 查找和统计

m.find(key);		//查找key元素是否存在，返回该元素的迭代器	m.count(key);		//统计key元素的个数