C++模板库--容器

标准模板库
     容器：各种各样的数据结构，存储数据：数组，联邦，栈，队列，树...
     迭代器：提供了一种同一的方式去遍历容器中的数据
     算法：处理数据，排序，查找，遍历...


容器算法迭代器关系
   （1）#include <iostream>
#include <vector>
#include <algorithm>
容器：数据结构的封装，用来存储数据
数组：vector
vectot<int> v;
v.push_back(3);
v.push_back(2);
v.push_back(9);
v.push_back(10);//在尾部插入数据


   （2）迭代器：给容器提供一种同一的遍历方式，相当于指针，指向容器中的某一个数据
begin();当前容器中第一个数据的迭代器
end();当前容器中最后一个元素的下一个元素的迭代器
vector<int>::iterator it;//iterator(迭代器类型) it(变量)
for(it = v.begin();it != v.end();it++)
{
cout << *it << endl;
}
/*while(it != v.end())
{
cout << *it << endl;
it++;
}*/
   （3）算法：处理数据，排序，查找，反转，遍历...
统计：count
int num = count(v.begin(),v.end(),9);
cout << num << endl;


标准模板库--容器


1.默认构造
string:
string();//构造一个空的字符串

string s1;
vector:
vector<T> vecT;//一个存放T的...容器
vector<int> vecInt;//一个存放int的...容器
vector<float> vecFloat;//一个存放float的...容器
vectot<string> vecString;//一个存放string的...容器
...//尖括号内还可以设置指针类型或自定义类型
deque:
deque<T> deqT;
deque<int> deqInt;
deque<float> deqFloat;
deque<string> deqString;
...
stack:
stack<T> stkT;
stack<int> stkInt;
stack<float> stkFloat;
stack<string> stkString;
...
list:
list<T> lstT;
list<int> lstInt;
list<float> lstFloat;
list<string> lstString;
...
set/multiset:
set<T> setT;
set<int> setInt;
set<float> setFloat;
set<string> setString;
...
multiset<T> mulT;
multiset<int> mulInt;
multiset<float> mulFloat;
multiset<string> mulString;
...
map/multimap:
map<T1,T2> mapTT;
multimap<T1,T2> multimapTT;

map<int,char> mapA;
map<string,float> mapB;
...//其中T1，T2还可以各种指针类型或自定义类型
2.带参数的构造函数
string:
string(const char* s);//用字符串s初始化
string(int n,char c);//用n个字符c初始化
vector:
vector(beg,end);//构造函数将[beg,end)区间的元素拷贝给本身。
vector(n,elem);//构造函数将几个elem拷贝给本身。


int iArray[] = {0,1,2,3,4};
vector<int> vecIntA(iArray,iArray+5);
vector<int> vecIntB(vecIntA.begin(),vecIntA.end());
vector<int> vecIntB(vecIntA.begin(),vecIntA.begin()+3);
vector<int> vecIntC(3,9);

...
deque:
deque(beg,end);
deque(n,elem);


deque<int> deqIntA;
deqIntA.push_back(1);
...
deque<int> deqIntB(deqIntA.begin(),deqIntA.end());
deque<int> deqIntC(5,8);

...
list:
list(beg,end);
list(n,elem);


list<int> lstIntA;
lstIntA.push_back(1);
...
list<int> lstIntB(lstIntA.begin(),lstIntA.end());
list<int> lstIntC(5,8);

...
3.拷贝构造函数
string:
string(const string &str);//构造一个与str一样的字符串

string s2(s1);
vector:
vector(const vector &vec);//拷贝构造函数
vector<int> vecIntD(vecIntA);
deque:
deque(const deque &deq);
deque<int> deqIntD(deqIntA);
list:
list(const list &lst);
list<int> lstIntD(lstIntA);
stack:
stack(const stack &stk);//拷贝构造函数
queue:
queue(const queue &que);//拷贝构造函数
set/multiset:
set(const set &set);//拷贝构造函数
map/mutltimap:
map(conset map &mp);



4.赋值
string:
string & assign(const char *s);//把字符串s赋给当前的字符串
string & assign(const char *s,int n);//把字符串s的前几个字符赋给当前的字符串
string & assign(const string &s);//把字符串s赋给当前的字符串
string & assign(int n,char c);//将几个字符c赋给当前字符串
string & assign(const string &s,int start,int n);//把字符串s中从start开始的几个字符赋给当前字符串
string & operator=(const string &s);//把字符串s赋给当前的字符串//重载等号操作符
vector:
vector.assign(beg,end);//将[beg,end)区间的数据拷贝赋值给本身
vector.assign(n,elem);//将n个elem拷贝赋值给本身
vector &operator=(const vector &vec);//重载等号操作符
vector.swap(vec);//将vec和本身元素互换

vector<int> vecIntA,vecIntB,vecIntC,vecIntD;
int iArray = {0,1,2,3,4};
vecIntA.assign(iArray,iArray+5);
vecIntB.assign(vecIntA.begin(),vecIntA.end());
vecIntC.assign(3,9);
vecIntD = vecIntA;
vecIntA.swap(vecIntD);
...
deque:
deque.assign(beg,end);
deque.assign(n,elem);
deque &operator=(const deque &deq);
deque.swap(deq);

deque<int> deqIntA,deqIntB,deqIntC,deqIntD;
deqIntA.push_back(1);
...
deqIntB.assign(deqIntA.begin(),deqIntA.end());
deqIntC.assign(3,9);
deqIntD = deqIntA;
deqIntC.swap(deqIntD);
...
list:
list.assign(beg,end);
list.assign(n,elem);
list &operator=(const list &lst);
list.swap(lst);


list<int> lstIntA,lstIntB,lstIntC,lstIntD;
lstIntA.push_back(1);
...
lstIntB.assign(lstIntA.begin(),lstIntA.end());
lstIntC.assign(3,9);
lstIntD = lstIntA;
lstIntC.swap(lstIntD);
...
stack:
stack & operator=(const stack &stk);//重载等号操作符
queue:
queue & operator=(const queue &que);
set/multiset:
set & operator=(const set &set);
set.swap(set);
map/multimap:
map & operator=(const map &mp);
map.swap(mp);
5.大小
string:
int length() const;//返回当前字符串的长度。不包括结尾的‘\0'
bool empty();//当前字符串是否为空
vector:
vector.size();//返回容器中元素的个数
vector.empty();//判断容器是否为空
vector.resize(num);//重新指定容器的长度为num，若容器变长，则以默认值填充新位置。如果容器变短，则尾部超出容器长度的元素被删除。
vector.resize(num,elem);//重新指定容器的长度为num，若容器变长，则以elem值填充新位置，如果容器变短，则尾部超出容器长度的元素被删除。

int iSize = vecInt.size();
bool bEmpty = vecInt.empty();
vecInt.resize(2);
vecInt.resize(10,2);
...
deque:
deque.size();
deque.empty();
deque.resize(num);
deque.resize(num,elem);


list:
list.size();
list.empty();
list.resize(num);
list.resize(num,elem);


stack:
stack.size();//判断堆栈的大小
stack.empty();//判断堆栈是否为空

queue:
queue.size();//判断队列的大小
queue.empty();//判断队列是否为空
set:
set.size();
set.empty();
map:
map.size();
map.empty();

6.中间插入
string:
string & insert(int pos,const char *s);//在pos位置插入字符串s
string & insert(int pos,const string &s);//在pos位置插入字符串s
string & insert(int pos,int n,char c);//在pos位置插入n个字符c
vector:
vector.insert(pos,elem);//在pos位置插入一个elem元素的拷贝，返回这个数据的位置
vector.insert(pos,n,elem);//在pos位置插入几个elem数据，无返回值
vector.insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据，无返回值



vec.insert(vec.begin(),11);
vec.insert(vec.begin()+1,2,33);
vec.insert(vecA.begin(),vecB.begin(),vecB.end());

deque:
deque.insert(pos,elem);
deque.insert(pos,n,elem);
deque.insert(pos.beg,end);
list:
list.insert(pos,elem);
list.insert(pos,n,elem);
list.insert(pos,beg,end);


stack,queue没有


set:
set.insert(elem);//在容器中插入元素
map:
map.insert(...);//往容器插入元素，返回pair<iterator,bool)

在map中插入元素的三种方式
假设map<int,string> mapStu;
一：通过pair方式插入对象
mapStu.insert(pair<int,string>(3,"小张"));
二：通过pair的方式插入对象
mapStu.insert(make_pair(-1,"小张-1"));
三：通过value_type的方式插入对象
mapStu.insert(map<int,string>::value_type(1,"小李"));
7.末尾添加和删除
string字符串连接:
stirng & operator+=(const string &s);//把字符串s连接到当前字符串结尾
string & operator+=(const char *s);//把字符串s连接到当前字符串结尾
string & append(const char *s);//把字符串s连接到当前字符串结尾
string & append(const char *s,int n);//把字符串s的前n个字符连接到当前字符串结尾
string & append(const string &s);//同operator+=()一样
string & append(const string &s,int pos,int n);//把字符串s中从pos开始的几个字符串连接到当前字符串结尾
string & append(int n,char c);//在当前字符串结尾添加n个字符c


vector:
vec.push_back(elem);//尾部插入
vec.push_back(1);
deque:
deque.push_back(elem);//在容器尾部添加一个数据
deque.push_front(elem);//在容器头部插入一个数据
deque.pop_back();//删除容器最后一个数据
deque.pop_front();//删除容器第一个数据


deq.push_back(1);
deq.push_front(2);
deq.pop_front();
deq.pop_back();
list:
list.push_back(elem);//在容器尾部添加一个数据
list.push_front(elem);//在容器头部插入一个数据
list.pop_back();//删除容器最后一个数据
list.pop_front();//删除容器第一个数据
stack:
stack.push(elem);//往栈头添加元素
stack.pop();//从栈头移除第一个元素

stk.push(1);
stk.pop();
queue:
queue.push(elem);//往栈头添加元素
queue.pop();//从栈头移除第一个元素

que.push(1);
que.pop();
set,map没有


8.数据存取
vector:
vec.at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range异常
vec[idx];//返回索引idx所指的数据，越界时，运行直接报错
vec.front();//返回第一个数据
vec.back();//返回最后一个数据


vector<int> vecInt;
vecInt.at(2);//== vecInt[2];
vecInt.at(2) = 8;//vecInt[2] = 8;


int iF = vector.front();
int iB = vector.back();
vector.front() = 11;
vector.back() = 19;


deque:
deque.at(idx);//返回索引idx所指的数据，如果idx越界，抛出out_of_range异常
deque[idx];//返回索引idx所指的数据，越界时，运行直接报错
deque.front();//返回第一个数据
deque.back();//返回最后一个数据


deque<int> deqInt;
deqInt.at(2);//== deqInt[2];
deqInt.at(2) = 8;//deqInt[2] = 8;


int iF = deque.front();
int iB = deque.back();
deque.front() = 11;
deque.back() = 19;
list:
list.front();//返回第一个元素
list.back();//返回最后一个元素
queue:
queue.front();//返回第一个元素
queue.back();//返回最后一个元素
stack:
stack.top();//返回最后一个压入栈元素
set,map没有
9.删除
string:
string & erase(int pos = 0;int n = npos);//删除pos开始的n个字符，返回修改后的字符串
vector:
vector.clear();//移除容器的所有数据
vector.erase(beg,end);//删除[beg,end)区间的数据，返回下一个数据的位置
vector.erase(pos);//删除pos位置的数据，返回下一个数据的位置

删除区间内的元素：
vector<int>::iterator itBegin = vec.begin()+1;
vector<int>::iterator itEnd = vec.begin()+2;
vec.erase(itBegin,itEnd);

删除容器中等于3的元素
for(vector<int>::iterator it = vec.begin();it != vec.end();)
{
if(*it == 3)
{
it = vec.erase(it);//以迭代器为参数，删除元素3，并把数据删除后的下一个元素的位置返回给迭代器
}
else
{
++it;
}
}

删除所有元素
vector.clear();//容器为空
vec.clear();


deque:
deque.clear();
deque.erase(beg,end);
deque.erase(pos);


删除区间内的元素：
deque<int>::iterator itBegin = deq.begin()+1;
deque<int>::iterator itEnd = deq.begin()+2;
deq.erase(itBegin,itEnd);

删除容器中等于3的元素
for(deque<int>::iterator it = deq.begin();it != deq.end();)
{
if(*it == 3)
{
it = deq.erase(it);
}
else
{
++it;
}
}


删除所有元素
deque.clear();
deq.clear();


list:
list.clear();
list.erase(beg,end);
list.erase(pos);


删除区间内的元素：
dequ<int>::iterator itBegin = deq.begin();
++itBegin;
deque<int>::iterator itEnd = deq.begin();
++itEnd;
++itEnd;
++itEnd;
deq.erase(itBegin,itEnd);


删除容器中等于3的元素方法一
for(deque<int>::iterator it = deq.begin();it != deq.end();)
{
if(*it == 3)
{
it = deq.erase(it);
}
else
{
++it;
}
}

删除容器中等于3的元素方法一
list.remove(3);
lst.remove(3);


删除所有元素
deque.clear();
deq.clear();


stack,queue没有


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

删除区间内的元素
set<int>::iterator itBegin = setInt.begin();
++itBegin;
set<int>::iterator itEnd = setInt.begin();
++itEnd;
++itEnd;
++itEnd;
setInt.erase(itBegin,itEnd);

删除容器中第一个元素
setInt.srase(setInt.begin());


删除容器中值为9的元素
setInt.erase(9);


删除setInt的所有元素
setInt.clear();//容器为空
map:
map.clear();
map.erase(pos);//删除pos迭代器所指的元素返回下一个元素的迭代器
map.erase(beg,end);//删除区间[beg,end)的所有元素，返回下一个元素的迭代器
map.erase(keyElem);//删除容器中key为keyElem的对组
10.与迭代器的配合使用


双向迭代器支持的操作：
it++;++it;it--;--it;*it;itA = itB;itA==itB;itA!=itB;
其中list，set,multiset,map,multimap支持双向迭代器。
随机访问迭代器支持的操作：
it+=i;it-=i;it+i(it=it+i);it[i];itA<itB;itA<=itB;itA>itB;itA>=itB;
其中，vector,deque支持随机访问迭代器
string:
string s1;
s1.begin();
s1.end();
vector:
vector.begin();//返回容器中第一个元素的迭代器
vector.end();//返回容器中最后一个元素后面的迭代器
vector.rbegin();//返回容器中最后一个元素的迭代器
vector.rend();//返回容器中倒数最后一个元素后面的迭代器


正向遍历：
for(vector<int>::iterator it = vec.begin();it != vec.end();++it)
{
cout << *it << " ";
}


逆向遍历：
for(vector<int>::reverse_iterator rit = vec.rbegin();rit != vec.rend();++rit)
{
cout << *rit << " ";
}
deque:
deque.begin();//返回容器中第一个元素的迭代器
deque.end();//返回容器中最后一个元素后面的迭代器
dequw.rbegin();//返回容器中最后一个元素的迭代器
deque.rend();//返回容器中倒数最后一个元素后面的迭代器


正向遍历：
for(deque<int>::iterator it = deq.begin();it != deq.end();++it)
{
cout << *it << " ";
}


逆向遍历：
for(deque<int>::reverse_iterator rit = deq.rbegin();rit != deq.rend();++rit)
{
cout << *rit << " ";
}
list:
list.begin();//返回容器中第一个元素的迭代器
list.end();//返回容器中最后一个元素后面的迭代器
list.rbegin();//返回容器中最后一个元素的迭代器
list.rend();//返回容器中倒数最后一个元素后面的迭代器


正向遍历：
for(list<int>::iterator it = lst.begin();it != lst.end();++it)
{
cout << *it << " ";
}


逆向遍历：
for(lst<int>::reverse_iterator rit = lst.rbegin();rit != lst.rend();++rit)
{
cout << *rit << " ";
}


stack,queue没有迭代器


set:
set.begin();//返回容器中第一个元素的迭代器
set.end();//返回容器中最后一个元素后面的迭代器
set.rbegin();//返回容器中最后一个元素的迭代器
set.rend();//返回容器中倒数最后一个元素后面的迭代器
map:
map.begin();  //返回容器中第一个数据的迭代器。
map.end();  //返回容器中最后一个数据之后的迭代器。
map.rbegin();  //返回容器中倒数第一个元素的迭代器。
map.rend();   //返回容器中倒数最后一个元素的后面的迭代器。