STL 容器 算法 迭代器

STL 容器 算法 迭代器iterator

标准模板库（standard template library）
容器可以嵌套容器
序列式容器
元素的位置是由进入容器的时机和地点决定
关联式容器
有规则的容器
迭代器iterator：迭代器是一个封装了一个用来遍历容器元素的指针的类
算法algorithm：通过有限的步骤，解决问题

string 容器
string 封装了char*,管理这个字符串
string 封装了很多成员方法，find查找，copy拷贝，replace,insert不用考虑内存释放和越界
string 转char*通过c_str方法

1.拼接操作
s +=“abc”;
s +=s2;
s.append(s2);//在s后追加s2

2.查找：
int find(const string&str,int pos=0)const;
int pos=s.find(“a”);//查找第一次出现a的位置
int pos=s.rfind(“a”);//查找最后一次出现a的位置
3.替换:
s.replace(0,2,“111”);//将s字符串的0-2位置替换为111
string& replace(int pos ,int n,const string &str);
string& replace(int pos ,int n,const char *str);
4.比较：
int compare(const string &s)const;
int compare(const char *s)const;//与字符串s比较，逐个字符比较
返回值： >时返回1，<返回-1，==返回0
5.string 子串
string substr(int pos=0,int n=npos)const;//返回由pos开始的第n个字符组成的字符串
6.插入和删除
string &insert(int pos,const char *s);//在pos位置插入s
string &insert(int pos,const string &str);
string &insert(int pos,int n,char c);//指定位置插入n个字符c
string &erase(int pos,int n = npos);//删除从pos开始的n个字符

vector：向量，动态数组,单口容器
v.begin()第一个
v.end()最后一个的下一个
v.rend()最后一个的前一个
v.rbegin()最后一个
push_back()插入，pop_back()取出，insert()插入
vector实现动态增长原理
当插入新元素时，若空间不足，则会重新申请更大的一块空间内存，将原来数据拷贝到新空间，释放旧空间数据，再把新元素插入到新空间
所以vector 始终是一片连续的物理内存地址空间。
构造函数：
1.vector v;
2.vector(v.begin(),v.end());//将v[begin(),end())区间中元素拷贝给本身
3.vector(n,elem);//构造函数将n个elem拷贝给本身
4.vector(const vector &vec);//拷贝构造函数
例1:vector v2(arr,arr+sizeof(arr)/sizeof(int));
vector 常用赋值操作
1、v.assign(beg,end);//将[begin,end)区间中的数据拷贝
2、v.assign(n,elem);//将n个elem
3、.vector &operator = (const vector &vec);//重载=
4、v.swap(vec);//将vec与本身互换、注意这里是地址指针互换
vector 大小操作
1、.size();//返回容器中元素个数
2、.empty();//判断容器是否为空
3、.resize(int num);//重新指定容器长度，若容器变小,超出元素被删
4、.capacity();//容器的容量

queue 容器
队列容器，先进先出
不能遍历，不能随机存取，不提供迭代器
push(elem);
pop();
back();//返回队尾元素
front();//返回第一个元素
queue &operator = (const queue &que);
empty();
size()

list链表include
链表是由一系列结点组成，结点包含两个域，一个数据域，一个指针域。链表内存是非连续的。

list数据元素的插入和删除
push_back(elem);
pop_back();
push_front(elem);
pop_front();
insert(pos,elem);
insert(pos,n,elem);
insert(pos,beg,end);
clear();
erase(beg,end);
erase(pos);
remove(elem);删除容器中所有与elem匹配元素
其他接口：
back();
front();
assign(beg,end);
assign(n,elem);
list &operator = (const list &lst);
swap(lst);
reverse();//反转链表
lst.sort();

遍历操作：
for(list::iterator it = mList.begin();it != mList.end();it ++)
{
cout<< *it <<" ";
}
cout << endl;

算法sort，支持可随机访问容器list不支持只能自己提供访问方法list.sort();

set/multiset容器
特性：set是以RB-tree（红黑树为底层机制，查找效率非常好）
set/multiset会根据元素值自动排序
区别：
set中不允许重复元素。
multiset 允许重复元素。

set 提供迭代器访问，不可以通过迭代器改变元素值，关系set集合排序规则，只能先删除再添加改变

set构造函数
set < T > st;默认构造
multiset< T> mst ;
set(const set &st);拷贝构造函数
set 赋值操作
set&operator = (const set &st);
swap(st);
set 大小操作
size();
empty();
set 插入删除
insert(elem);
clear();
erase(pos);
erase(beg,end);
erase(elem);
set 查找操作
find(key);查找key,存在返回该元素迭代器，不存在返回end()
lower_bound (keyElem);返回第一个key>=keyElem的元素迭代器
upper_bound (keyElem);返回第一个key>keyElem的元素迭代器
equal_range(keyElem);返回容器中key与keyElem相等的上下限的两个迭代器，即lower-upper
仿函数：
class mycompare(){
public:
bool operator()(int v1,int v2){//重载括号（）
return v1>v2;
};
set<int,mycompare>set1;//使用类型实例化对象
pair<set::iterator,set::iterator>myret=mSet.equal_range();
myret.first();
myret.second();

对组pair
将一对值组合成一个值，这一对值可以具有不同的数据类型，两个值可以分别用pair的两个公有函数first和second访问
类模板：template<class T1,class T2>Struct pair;
创建对组
1.pair<int,int>mpair (10,20);
2.pair<string,int>mpair(string(“name”),20);
3.pair <string,int>mpair = make_pair(“name”,30);

map/multimap容器
map相对于set区别，map具有键值和实值，所有元素根据键值自动排序。
map也是以红黑树为底层实现机制。

map****键值不能重复
multimap****键值可以重复
和set一样，也不能通过迭代器修改键值，但可以改变实值

map构造函数：
map<T1,T2>mapTT;//默认构造
map(const map &mp);//拷贝构造
map赋值
map& operator = (const map &mp)
swap(mp);
map大小操作
size();
empty();
map插入数据元素操作
map.insert(…);//返回pair<iterator,bool>
map<int,string>mapStu;
1、mapStu.insert(pair<int,string>(3,“小张”));//第一种通过pair方式插入对象
2、mapStu.insert(make_pair(-1,“校长”));//通过make_pair方式插入
3、mapStu.insert(map<int,string>::value_type(),“小李”));//通过value_type方式插入
4、mapStu[3]=“小王”;//通过数组方式插入值
mapStu[5]=“小刘”;//没有就新建，有就修改value
前三种采用insert()方法，返回值pair<itertor,bool>
map查找
find(key);
count(keyElem);
lower_bound(keyElem);
upper_bound(keyElem);
equal_range(keyElem);

容器的深拷贝与浅拷贝
STL容器共性机制
STL容器所提供的都是值（value）寓意，而非引用（reference）,也就是当我们向容器中插入元素时，容器内部实施了拷贝动作，
所以我们提供的元素必须能够被拷贝。例如指针。

函数对象（仿函数）
重载函数调用操作符的类，其对象常称为函数对象，即它们是行为类似函数的对象，也叫仿函数，其实就是重载“（）”操作符，使得对象可以像仿函数那样调用
注意：
1、函数对象（仿函数）是一个类，不是一个函数。
2、函数对象（仿函数）重载了“（）”使它可以像函数一样调用。
假如某个类有一个重载的operator（），而且重载的operator（）
要求获取一个参数，我们就称这个类称为“一元仿函数”（unary functor） ,
相同，如果需要两个参数，则称“二元仿函数”（binary functor）
函数对象基本概念：
函数对象也可以有参数和返回值。
函数对象超出函数概念，可以保存函数调用状态。
函数对象做参数和返回值。

struct Myprint{
void operator() (int val){
cout<< val <<endl;
mNum++;
}
Myprint(){
mNum = 0;
}
public:
int mNum;
};

谓词概念
谓词是指普通函数或重载的operator（）返回值是bool类型的函数对象（仿函数）。如果operator接受一个参数，那么叫做二元谓词
谓词可作为一个判断式。

一元函数对象 应用举例：for_each()
一元谓词 ：find_if()
二元函数对象 ：transform
二元谓词 ：sort

STL内建函数对象
函数对象适配器，是完成一些配接工作，这些配接包括绑定（bind）,否定（negate），以及对一般函数或成员函数的修饰
使其成为函数对象，重点 函数对象适配器
bind1st:将参数绑定为函数对象的第一个参数
bind2st:将参数绑定为函数对象的第二个参数
not1：对一元函数对象取反
not2：对二元函数对象取反
ptr_fun：将普通函数修饰成函数对象
mem_fun：修饰成员函数 （对象指针用mem_fun）
mem_fun_ref:修饰成员函数

常用遍历算法
常用查找算法