一.概念
1. STL由一些可适应不同需求的集合类,以及在这些数据集合上操作的算法构成
2. STL中的三个主要组件
1)容器:用于存放数据的类模板,管理某类对象的集合
2)迭代器:在对象集合上进行遍历。是一个变量,作用类似于指针,访问容器中的元素需要通过迭代器
3)算法:用来操作容器中元素的函数模板
二.容器
1.要点
1)可以存放基本类型的变量,也可以存放对象
2)被放入容器中的对象所属的类最好重载”==”和”<”运算符
3)所有容器中存放的都是值而非引用。如果希望存放的不是副本,容器元素只能是指针
2.STL容器元素的条件
必须能够通过拷贝构造函数进行复制
必须可以通过赋值运算符完成赋值操作
必须可以通过析构函数完称销毁动作
序列式容器元素的默认构造函数必须可用
某些动作必须定义operator ==,例如搜寻操作
关联式容器必须定义出排序准则,默认情况是重载operator <
对于基本数据类型(int,long,char,double,…)而言,以上条件总是满足
3.容器的分类
1)序列式容器:
排列次序取决于插入时机和位置。即容器不是排序的,指定在什么位置插入,元素就在什么位置。
可变长动态数组vector,双端队列deque,双向链表list.
2)关联式容器:
排列顺序取决于特定的准则。即插入元素时,容器会按照一定的排序规则将元素放到适当的位置上,因此插入元素时不能指定位置。默认元素(或关键字)从小到大排序(”<”)
set,multiset,map,multimap
3)容器适配器——特殊性顺序表
stack,queue ,priority_queue
4.初始化
1)产生一个空容器:std::list<int> l;
2)以另一个容器元素为初值完成初始化:
std::list<int>l;
…
std::vector<float>c(l.begin(),l.end());
3)以数组元素为初值完成初始化
intarray[]={2,4,6,1345};
…
std::set<int>c(array,array+sizeof(array)/sizeof(array[0]));
5.比较
任何两个容器对象,只要他们的类型相同,就可以用==,!=,<,<=,>,>= 进行比较
1) a==b : a和b中的元素个数相同且对应元素相等
2) a<b : 从头到尾比较每个元素,若发生a中的元素小于b中的元素的情况,则a<b的值为ture;若没有发生b中的元素小于a中的元素的情况,且a中的元素个数比b中的少,则a<b的值为ture,其他情况下为false
3) a!=b :等价于!(a==b)
4) a>b :等价于b<a
5) a<=b :等价于!(b<a)
6) a>=b :等价于!(a<b)
6.容器的成员函数
1) 与大小相关的操作
int size()-返回当前容器的元素数量
bool empty()-判断容器是否为空
max_size()-返回容器能容纳的最大元素数量
2) 交换
swap--用于提高赋值操作效率
3) 与迭代器相关的操作
begin()-返回一个迭代器,指向第一个元素
end()-返回一个迭代器,指向最后一个元素之后
rbegin()-返回一个逆向迭代器,指向逆向遍历的第一个元素
rend()-返回一个逆向迭代器,指向逆向遍历的最后一个元素之后
4) 元素操作
insert(pos,e)-将元素e的拷贝安插于迭代器pos所指的位置
erase(beg,end)-移除[beg,end]区间内的所有元素
clear()-移除所有元素
front():返回容器中第一个元素的引用
back():返回容器中最后一个元素的引用
push_back:在容器末尾增加新元素
pop_back:删除容器末尾的元素
7.vector模拟动态数组
能够存放任意类型的元素
1)构造,拷贝和析构
vector<T> c | 产生空的vector |
vector<T> c1(c2)
| 产生同类型的c1,并将复制c2的所有元素 |
vector<T> c(n)
| 利用类型T的默认构造函数和拷贝构造函数生成一个大小为n的vector |
vector<T> c(n,e)
| 产生一个大小为n的vector,每个元素都是e |
vector<T> c(beg,end)
| 产生一个vector,以区间[beg,end]为元素初值 |
~vector<T>() | 销毁所有元素并释放内存 |
2).非变动操作
c.size() | 返回元素个数 |
c.empty() | 判断容器是否为空 |
c.max_size() | 返回元素最大可能数量(固定值) |
c.capacity() | 返回重新分配空间前可容纳的最大元素数量 |
c.reserve(n) | 扩大容量为n |
c1==c2 | 判断c1是否等于c2 |
c1!=c2 | 判断c1是否不等于c2 |
c1<c2 | 判断c1是否小于c2 |
c1>c2 | 判断c1是否大于c2 |
c1<=c2 | 判断c1是否大于等于c2 |
c1>=c2 | 判断c1是否小于等于c2 |
3)赋值操作
c1 = c2 | 将c2的全部元素赋值给c1 |
c.assign(n,e) | 将元素e的n个拷贝赋值给c |
c.assign(beg,end) | 将区间[beg,end]的元素赋值给c |
c1.swap(c2) | 将c1和c2元素互换 |
swap(c1,c2) | 同上,全局函数 |
注:所有的赋值操作都有可能调用元素类型的默认构造函数,拷贝构造函数,赋值操作符和析构函数
4)元素存取
at(idx) | 返回索引idx所标识的元素的引用,进行越界检查 |
operator [](idx) | 返回索引idx所标识的元素的引用,不进行越界检查 |
front() | 返回第一个元素的引用,不检查元素是否存在 |
back() | 返回最后一个元素的引用,不检查元素是否存在 |
5)迭代器相关函数
同容器
注:迭代器持续有效,除非发生以下两种情况:
(1)删除或插入元素
(2)容量变化而引起内存重新分配
6)安插元素insert
c.insert(pos,e) | 在pos位置插入元素e的副本,并返回新元素位置 |
c.insert(pos,n,e) | 在pos位置插入n个元素e的副本 |
c.insert(pos,beg,end) | 在pos位置插入区间[beg,end]内所有元素的副本 |
c.push_back(e) | 在尾部添加一个元素e的副本 |
7) 移除元素
c.pop_back() | 移除最后一个元素但不返回最后一个元素 |
c.erase(pos) | 删除pos位置的元素,返回下一个元素的位置 |
c.erase(beg,end) | 删除区间[beg,end]内所有元素,返回下一个元素的位置 |
c.clear() | 移除所有元素,清空容器 |
c.resize(num) | 将元素数量改为num(增加的元素用defalut构造函数产生,多余的元素被删除) |
c.resize(num,e) | 将元素数量改为num(增加的元素是e的副本) |
8.map/multimap
元素包含两部分(key,value),key和value可以是任意类型
根据元素的key自动对元素排序
不能直接改变元素的key,可以通过operator []直接存取元素值
map中不允许key相同的元素,multimap允许key相同的元素
1)构造、拷贝和析构
map c | 产生空的map |
map c1(c2) | 产生同类型的c1,并复制c2的所有元素 |
map c(op) | 以op为排序准则产生一个空的map |
map c(beg,end) | 以区间[beg,end]内的元素产生一个map |
map c(beg,end,op) | 以op为排序准则,以区间[beg,end]内的元素产生一个map |
~ map() | 销毁所有元素并释放内存。 |
其中map可以是下列形式
map<key,value> 一个以less(<)为排序准则的map,
map<key,value,op> 一个以op为排序准则的map
2)非变动性操作
c.size() | 返回元素个数 |
c.empty() | 判断容器是否为空 |
c.max_size() | 返回元素最大可能数量 |
c1==c2 | 判断c1是否等于c2 |
c1!=c2 | 判断c1是否不等于c2 |
c1<c2 | 判断c1是否小于c2 |
c1>c2 | 判断c1是否大于c2 |
c1<=c2 | 判断c1是否大于等于c2 |
c1>=c2 | 判断c1是否小于等于c2 |
3)赋值
c1 = c2 | 将c2的全部元素赋值给c1 |
c1.swap(c2) | 将c1和c2的元素互换 |
swap(c1,c2) | 同上,全局函数 |
4)特殊搜寻操作
count(key) | 返回”键值等于key”的元素个数 |
find(key) | 返回”键值等于key”的第一个元素,找不到返回end |
lower_bound(key) | 返回”键值大于等于key”的第一个元素 |
upper_bound(key) | 返回”键值大于key”的第一个元素 |
equal_range(key) | 返回”键值等于key”的元素区间 |
5)迭代器相关函数
同容器
6)安插元素insert
c.insert(pos,e) | 在pos位置为起点插入e的副本,并返回新元素位置(插入速度取决于pos) |
c.insert(e) | 插入e的副本,并返回新元素位置 |
c.insert(beg,end) | 将区间[beg,end]内所有元素的副本插入到c中 |
7)移除元素
c.erase(pos) | 删除迭代器pos所指位置的元素,无返回值 |
c.erase(val) | 移除所有值为val的元素,返回移除元素个数 |
c.erase(beg,end) | 删除区间[beg,end]内所有元素,无返回值 |
c.clear() | 移除所有元素,清空容器 |
9.set/multiset
set中不允许key相同的元素,multiset允许key相同的元素
返回指向第一个元素的迭代器 | |
清除所有元素 | |
返回某个值元素的个数 | |
如果集合为空,返回true | |
返回指向最后一个元素的迭代器 | |
返回集合中与给定值相等的上下限的两个迭代器 | |
删除集合中的元素 | |
返回一个指向被查找到元素的迭代器 | |
返回集合的分配器 | |
在集合中插入元素 | |
返回指向大于(或等于)某值的第一个元素的迭代器 | |
返回一个用于元素间值比较的函数 | |
返回集合能容纳的元素的最大限值 | |
返回指向集合中最后一个元素的反向迭代器 | |
返回指向集合中第一个元素的反向迭代器 | |
集合中元素的数目 | |
交换两个集合变量 | |
返回大于某个值元素的迭代器 | |
返回一个用于比较元素间的值的函数 |
三.迭代器
* | 返回当前位置上的元素值。如果该元素有成员,可以通过迭代器以operator ->取用 |
++ | 将迭代器前进至下一元素 |
==和!= | 判断两个迭代器是否指向同一位置 |
= | 为迭代器赋值(将所指元素的位置赋值过去) |
2)所有容器都提供获得迭代器的函数
begin() | 返回一个迭代器,指向第一个元素 |
end() | 返回一个迭代器,指向最后一个元素之后 |
3)所有容器都提供两种迭代器
container::iterator以“读/写”模式遍历元素
container::const_iterator以“只读”模式遍历元素
4)迭代器分类
---双向迭代器
可以双向行进,以递增运算前进或以递减运算后退、可以用==和!=比较。
list、set和map提供双向迭代器
---随机存取迭代器
除了具备双向迭代器的所有属性,还具备随机访问能力。
可以对迭代器增加或减少一个偏移量、处理迭代器之间的距离或者使用<和>之类的关系运算符比较两个迭代器。
vector、deque和string提供随机存取迭代器
四.算法
泛型算法通则
所有算法的前两个参数都是一对iterators:[first,last),用来指出容器内一个范围内的元素。
1.count
template<class InIt, class T>
size_t count(InIt first, InIt last, const T& val);
计算[first,last) 中等于val的元素个数
2.count_if
template<class InIt, class Pred, class Dist>
size_t count_if(InIt first, InIt last, Pred pr);
计算[first,last) 中符合pr(e) == true 的元素 e的个数
3.min_element
template<class FwdIt>
FwdIt min_element(FwdIt first, FwdIt last);
返回[first,last) 中最小元素的迭代器,以“< ”作比较器
4.max_element
template<class FwdIt>
FwdIt max_element(FwdIt first, FwdIt last);
返回[first,last) 中最大(不小)元素的迭代器,以“< ”作比较器
5.for_each
template<class InIt, class Fun>
Fun for_each(InIt first, InIt last, Fun f);
对[first,last)中的每个元素 e ,执行 f(e) , 要求 f(e)不能改变e
6.find
template<class InIt, class T>
InIt find(InIt first, InIt last, const T& val);
返回区间 [first,last) 中的迭代器 i ,使得 * i == val
7. find_if
template<class InIt, class Pred>
InIt find_if(InIt first, InIt last, Pred pr);
返回区间 [first,last) 中的迭代器 i, 使得 pr(*i) == true
8.reverse
template<class BidIt>
void reverse(BidIt first, BidIt last);
颠倒区间[first,last)顺序
9.unique去重
template<class FwdIt>
FwdIt unique(FwdItfirst, FwdIt last);
用 == 比较是否相等
template<class FwdIt, class Pred>
FwdIt unique(FwdItfirst, FwdIt last, Pred pr);
用 pr 比较是否等
去除[first,last) 这个升序序列中的重复元素
返回值是迭代器,指向元素删除后的区间的最后一个元素的后面
例题
1
Vector<int> MyVec(100);//定义长度为100的向量
MyVec[50]=1024;//给向量某个元素赋值
int i=0;
for( ;i<25;i++)
{
MyVec,push_back(1);//向量末尾增加数值1
}
MyVec.resize(400);//重新定义向量长度为400
2
#include <iostream>
#include <map>
using namespace std;
ostream & operator <<( ostream & o,const pair< int,double> & p)
{
o << "(" << p.first << "," << p.second << ")";
return o;
}
int main() {
typedef map<int,double,less<int> > mmid;
mmid pairs;
cout << "1) " << pairs.count(15) << endl;
pairs.insert(mmid::value_type(15,2.7));
pairs.insert(make_pair(15,99.3)); //make_pair生成一个pair对象
cout << "2) " << pairs.count(15) << endl;
pairs.insert(mmid::value_type(20,9.3));
mmid::iterator i;
cout << "3) ";
for( i = pairs.begin(); i != pairs.end();i ++ )
cout << * i << ",";
cout << endl;
cout << "4) ";
int n = pairs[40];//如果没有关键字为40的元素,则插入一个
for( i = pairs.begin(); i != pairs.end();i ++ )
cout << * i << ",";
cout << endl;
cout << "5) ";
pairs[15] = 6.28; //把关键字为15的元素值改成6.28
for( i = pairs.begin(); i != pairs.end();i ++ )
cout << * i << ",";
}
心得
STL包括很多数据结构和算法,虽然短时间内记忆起来有些难度(平时多用用),但是可以使编写程序的速度更快,印象最深的就是sort函数,之前学习的什么冒泡排序啊,快速排序啊,说实话学的一点都不好,甚至不大会用,很苦恼,但是sort函数完美的解决了这个问题,往往一条语句就解决了问题!所以说,STL是很有用的,能使我们的代码跟简洁,更快速。