C++基础学习笔记09——STL

STL

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

1. STL初识

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

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

vector嵌套：

	vector< vector<int> > v;
	vector<int> v1;
	vector<int> v2;
	vector<int> 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<int> >::iterator it=v.begin();it!=v.end();it++){
		for(vector<int>::iterator vit=(*it).begin;vit!=(*it).end;vit++){
			cout<<*vit<<endl;
		}
	}

相当于二维数组

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

3.3 赋值

	vector<int> v2;
	v2=v1;
	vector<int> v3;
	v3.assign(v1.begin(),v1.end());	//将begin()到end()的值赋值给v3 
	vector<int> 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<<v1[idx];	//返回索引idx所指的数据
	v1.front();		//返回容器中第一个数据元素
	v1.back();		//返回容器中最后一个数据元素 

4. deque容器

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

4.1 构造

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

4.2 赋值

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

4.3 deque容量和大小

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

4.4 插入和删除

	deque<int> 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<<d1[idx];	//返回索引idx所指的数据
	d1.front();		//返回容器中第一个数据元素
	d1.back();		//返回容器中最后一个数据元素

5. stack容器

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

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

6. queue容器

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

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

7. list容器

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

7.1 构造

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

7.2 赋值

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

7.3 大小

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

7.3 插入和删除

	list<int> 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<int> 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<string,int> p1("Tom",18);
	pair<string,int> p2=make_pair("Jerry",18);
	cout<<p1.first<<" "<<p1.second<<endl;
	cout<<p2.first<<" "<<p2.second<<endl;	//访问两个数据

10. map容器

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

10.1 构造

	map<int,int> m;
	m.insert(pair<int,int>(1,10));
	m.insert(pair<int,int>(2,20));
	m.insert(pair<int,int>(3,30));
	m.insert(pair<int,int>(4,40));
	for(map<int,int>::iterator it=m.begin();it!=m.end();it++){
		cout<<(*it).first<<" "<<(*it).second<<endl;		//访问map容器中的元素
	}

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<int,int>(1,10));
	m.insert(make_pair(2,20));
	m.insert(map<int,int>::value_type(3,30));
	m[4]=40;

10.4 查找和统计

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