程序设计B_作业二——STL内容总结和课程感受

一、STL概述

1、定义

STL是C++标准程序库的核心，深刻影响了标准程序库的整体结构

STL由一些可适应不同需求的集合类（collection class），以及在这些数据集合上操作的算法（algorithm）构成

STL内的所有组件都由模板（template）构成，其元素可以是任意类型

STL是所有C++编译器和所有操作系统平台都支持的一种库STL组件

2、STL组件

Ø容器（Container）－管理某类对象的集合

Ø迭代器（Iterator）－在对象集合上进行遍历

Ø算法（Algorithm）－处理集合内的元素

Ø容器适配器（container adaptor）

Ø函数对象(functor)

3、STL容器类别

Ø序列式容器－排列次序取决于插入时机和位置

Ø关联式容器－排列顺序取决于特定准则

4、STL容器的共同操作

Ø与大小相关的操作（size operator）

size()－返回当前容器的元素数量

empty()－判断容器是否为空

max_size()－返回容器能容纳的最大元素数量

Ø比较（comparison）

==,!=,<,<=,>,>=

比较操作两端的容器必须属于同一类型

如果两个容器内的所有元素按序相等，那么这两个容器相等

采用字典式顺序判断某个容器是否小于另一个容器

Ø赋值（assignment）和交换（swap）

swap用于提高赋值操作效率

Ø与迭代器（iterator）相关的操作

begin()－返回一个迭代器，指向第一个元素

end()－返回一个迭代器，指向最后一个元素之后

rbegin()－返回一个逆向迭代器，指向逆向遍历的第一个元素

rend()－返回一个逆向迭代器，指向逆向遍历的最后一个元素之后

Ø元素操作

insert(pos,e)－将元素e的拷贝安插于迭代器pos所指的位置

erase(beg,end)－移除[beg，end]区间内的所有元素

clear()－移除所有元素

5、迭代器（iterator）（示例:iterator）

操作	效果
*	返回当前位置上的元素值。如果该元素有成员，可以通过迭代器以operator ->取用
++	将迭代器前进至下一元素
==和!=	判断两个迭代器是否指向同一位置
=	为迭代器赋值（将所指元素的位置赋值过去）

Ø所有容器都提供获得迭代器的函数

程序设计B_作业二——STL内容总结和课程感受

Ø迭代器分类

双向迭代器

可以双向行进,以递增运算前进或以递减运算后退、可以用==和!=比较。

list、set和map提供双向迭代器

随机存取迭代器

除了具备双向迭代器的所有属性，还具备随机访问能力。

可以对迭代器增加或减少一个偏移量、处理迭代器之间的距离或者使用<和>之类的关系运算符比较两个迭代器。

vector、deque和string提供随机存取迭代器

二、STL容器

1、vector

Øvector模拟动态数组

Øvector的元素可以是任意类型T，但必须具备赋值和拷贝能力（具有public拷贝构造函数和重载的赋值操作符）

Ø必须包含的头文件#include <vector>

Øvector支持随机存取

Øvector的大小（size）和容量（capacity）

size返回实际元素个数，

capacity返回vector能容纳的元素最大数量。如果插入元素时，元素个数超过capacity，需要重新配置内部存储器。

Ø构造、拷贝和析构

操作	效果
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>()	销毁所有元素并释放内存。

Ø非变动操作

操作	效果
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

Ø赋值操作

操作	效果
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)	同上，全局函数

Ø元素存取

操作		效果
at(idx)	返回索引idx所标识的元素的引用，进行越界检查
operator [](idx)	返回索引idx所标识的元素的引用，不进行越界检查
front()	返回第一个元素的引用，不检查元素是否存在
back()	返回最后一个元素的引用，不检查元素是否存在

Ø迭代器相关函数

操作	效果
begin()	返回一个迭代器，指向第一个元素
end()	返回一个迭代器，指向最后一个元素之后
rbegin()	返回一个逆向迭代器，指向逆向遍历的第一个元素
rend()	返回一个逆向迭代器，指向逆向遍历的最后一个元素

Ø安插（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的副本

Ø移除（remove）元素

操作	效果
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的副本）

2、map/multimap

Ø使用平衡二叉树管理元素

Ø元素包含两部分(key,value)，key和value可以是任意类型

Ø必须包含的头文件#include <map>

Ø根据元素的key自动对元素排序，因此根据元素的key进行定位很快，但根据元素的value定位很慢

Ø不能直接改变元素的key，可以通过operator []直接存取元素值

Ømap中不允许key相同的元素，multimap允许key相同的元素

Ø内部存储结构

Ø构造、拷贝和析构

操作	效果
*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*()	销毁所有元素并释放内存。

Ø非变动性操作

操作	效果
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

Ø赋值

操作	效果
c1 = c2	将c2的全部元素赋值给c1
c1.swap(c2)	将c1和c2的元素互换
swap(c1,c2)	同上，全局函数

Ø特殊搜寻操作

操作	效果
count(key)	返回”键值等于key”的元素个数
find(key)	返回”键值等于key”的第一个元素，找不到返回end
lower_bound(key)	返回”键值大于等于key”的第一个元素
upper_bound(key)	返回”键值大于key”的第一个元素
equal_range(key)	返回”键值等于key”的元素区间

Ø迭代器相关函数

操作	效果
begin()	返回一个双向迭代器，指向第一个元素
end()	返回一个双向迭代器，指向最后一个元素之后
rbegin()	返回一个逆向迭代器，指向逆向遍历的第一个元素
rend()	返回一个逆向迭代器，指向逆向遍历的最后一个元素

Ø安插（insert）元素

操作	效果
c.insert(pos,e)	在pos位置为起点插入e的副本，并返回新元素位置（插入速度取决于pos）
c.insert(e)	插入e的副本，并返回新元素位置
c.insert(beg,end)	将区间[beg,end]内所有元素的副本插入到c中

Ø移除（remove）元素

操作	效果
c.erase(pos)	删除迭代器pos所指位置的元素，无返回值
c.erase(val)	移除所有值为val的元素，返回移除元素个数
c.erase(beg,end)	删除区间[beg,end]内所有元素，无返回值
c.clear()	移除所有元素，清空容器

3、set/multiset

Ø使用平衡二叉树管理元素

Ø集合(Set)是一种包含已排序对象的关联容器。

Ø必须包含的头文件#include <set>

Ømap容器是键-值对的集合，好比以人名为键的地址和电话号码。相反地，set容器只是单纯的键的集合。当我们想知道某位用户是否存在时，使用set容器是最合适的。

Øset中不允许key相同的元素，multiset允许key相同的元素

操作	效果
begin()	返回指向第一个元素的迭代器
clear()	清除所有元素
count()	返回某个值元素的个数
empty()	如果集合为空，返回true
end()	返回指向最后一个元素的迭代器
equal_range()	返回集合中与给定值相等的上下限的两个迭代器
erase()	删除集合中的元素
find()	返回一个指向被查找到元素的迭代器
get_allocator()	返回集合的分配器

操作	效果
insert()	在集合中插入元素
lower_bound()	返回指向大于（或等于）某值的第一个元素的迭代器
key_comp()	返回一个用于元素间值比较的函数
max_size()	返回集合能容纳的元素的最大限值
rbegin()	返回指向集合中最后一个元素的反向迭代器
rend()	返回指向集合中第一个元素的反向迭代器
size()	集合中元素的数目
swap()	交换两个集合变量
upper_bound()	返回大于某个值元素的迭代器
value_comp()	返回一个用于比较元素间的值的函数

三、Algorithm（算法）

1、泛型算法通则

Ø所有算法的前两个参数都是一对iterators：[first，last)，用来指出容器内一个范围内的元素。

Ø每个算法的声明中，都表现出它所需要的最低层次的iterator类型。

2、算法

count:

size_t count(InIt first, InIt last, const T& val);

计算[first,last) 中等于val的元素个数

count_if

size_t count_if(InIt first, InIt last, Pred pr);

计算[first,last) 中符合pr(e) == true 的元素 e的个数

min_element:

template<class FwdIt>

FwdIt min_element(FwdIt first, FwdIt last);

返回[first,last) 中最小元素的迭代器,以 “< ”作比较器

max_element:

template<class FwdIt>

FwdIt max_element(FwdIt first, FwdIt last);

返回[first,last) 中最大(不小）元素的迭代器,以 “< ”作比较器

for_each

template<class InIt, class Fun>

Fun for_each(InIt first, InIt last, Fun f);

对[first,last)中的每个元素 e ,执行 f(e) , 要求 f(e)不能改变e

3、排序和查找算法

1)find

template<class InIt, class T>

InIt find(InIt first, InIt last, const T& val);

返回区间 [first,last) 中的迭代器 i ,使得 * i == val

2) find_if

template<class InIt, class Pred>

InIt find_if(InIt first, InIt last, Pred pr);

返回区间 [first,last) 中的迭代器 i, 使得 pr(*i) == true

3) binary_search 折半查找，要求容器已经有序且支持随机访问迭代器，返回是否找到

template<class FwdIt, class T>

bool binary_search(FwdIt first, FwdIt last, const T& val);

上面这个版本，比较两个元素x,y 大小时, 看 x < y

template<class FwdIt, class T, class Pred>

bool binary_search(FwdIt first, FwdIt last, const T& val, Pred pr);

上面这个版本，比较两个元素x,y 大小时, 看 pr(x,y)

4) lower_bound,uper_bound, equal_range

lower_bound：

template<class FwdIt, class T>

FwdIt lower_bound(FwdIt first, FwdIt last, const T& val);

要求[first,last)是有序的，

查找大于等于val的最小的位置

upper_bound

template<class FwdIt, class T>

FwdIt upper_bound(FwdIt first, FwdIt last, const T& val);

要求[first,last)是有序的，

查找大于val的最小位置

equal_range

template<class FwdIt, class T>

pair<FwdIt, FwdIt> equal_range(FwdIt first, FwdIt last, const T& val);

要求[first,last)是有序的，

返回值是一个pair, 假设为 p, 则

[first,p.first) 中的元素都比 val 小

[p.second,last)中的所有元素都比 val 大

5)sort 快速排序

template<class RanIt>

void sort(RanIt first, RanIt last);

按升序排序。判断x是否应比y靠前，就看 x < y 是否为true

template<class RanIt, class Pred>

void sort(RanIt first, RanIt last, Pred pr);

按升序排序。判断x是否应比y靠前，就看 pr(x,y) 是否为true

6）改变序列的算法

template<class FwdIt>

FwdIt unique(FwdIt first, FwdIt last);

用 == 比较是否相等

template<class FwdIt, class Pred>

FwdIt unique(FwdIt first, FwdIt last, Pred pr);

用 pr 比较是否等

去除[first,last) 这个升序序列中的重复元素

返回值是迭代器，指向元素删除后的区间的最后一个元素的后面

reverse

template<class BidIt>

void reverse(BidIt first, BidIt last);

颠倒区间[first,last)顺序

四、注意事项

1、STL内的所有组件都由模板（template）构成，其元素可以是任意类型。

2、模拟动态数组
必须包含的头文件#include<vector>

3、map/multimap
必须包含的头文件#include<map>

根据元素的key自动对元素排序，因此根据元素的key进行定位很快
map中不允许有key相同的元素，但multimap允许

map自带自动排序功能

map很多操作和vector是相似的，比如插入insert、清空clear、empty判空等

4、set/multiset
必须包含的头文件#include<set>

set中不允许有key相同的元素，但multiset允许

五、课程感受

开课这么久，课程已经过去大半了，始终是一种追赶的状态。经常觉得自己抓不到重点，上课听和自己真正动手做存在很大的差距，所以在以后的学习当中我一定会加强我的应用能力。并且听取老师的意见更多的去了解我们使用的这些“工具”背后的原理，是我们现在学到的都成为以后有用的。希望自己在接下来的时间里能更认真的完成老师的任务，更好的吸收和应用所学到的知识，千万不要浮躁。