C++STL容器知识点小结

vector< int >v2(存储元素个数，默认存储元素的数值);
例如:
vector<int>v2(10);
构造时就分配空间，同时插入默认元素0
指定容器中存储的元素个之后，此时该vector的容量和大小相等。	
(用默认vector的默认构造函数之后再往里面push_back的话，vector会自动开辟空间4个4个的扩容。)

vector<int>v3(v2);

vector<int>v4(v3.begin.() + x,v3.end());

int test[] = { 1,2,3,4,5 };
vector<int>v4(test, test + 3);

v2.assign(2,888);//改变vector中的元素个数和元素值
v2.assign(v3.begin(),v3.end());//使用迭代器赋值
v2.assign(test,test+3);//使用指针赋值 

v2 = v3;//调用赋值运算

v2.resize(4);//重新调整v2容器大小，多余的被抹除。不够的以0填充。

v2.resize(18,666);//扩充v2大小，以666填充

如果原来大小就是这么大，则不会发生变化。

v2.push_back(6);

v2.pop_back();

下标访问
    v2[1];

at
    v2.at(1)

接口返回引用
    v2.front();//取到第一个元素
	v2.end();//取到最后一个元素

//插入单个元素
v2.insert(迭代器,插入的数值);
//插入多个元素
v2.insert(v2.begin(),3,888);//在开始的位置插入三个888
v2.insert(v2.begin(),v3.begin(),v3.end());//将v3的内容从v2开始插入进去。

//插入单个元素的时候返回值是一个迭代器

//把整个vector干掉
v2.clear();

//干掉的单个元素
v2.erase(v2.begin()+1);

//干掉多个元素
v2.erase(v2.begin(),b2.begin()+1);//不包括结尾，“左闭右开”

//删除单个元素返回值也是个迭代器

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

deque.begin();  //返回容器中第一个元素的迭代器。

deque.end();  //返回容器中最后一个元素之后的迭代器。

deque.rbegin();  //返回容器中倒数第一个元素的迭代器。

deque.rend();  //返回容器中倒数最后一个元素之后的迭代器。

deque.cbegin();  //返回容器中第一个元素的常量迭代器。

deque.cend();  //返回容器中最后一个元素之后的常量迭代器。

deque.assign(beg,end);    //将[beg, end)区间中的数据拷贝赋值给本身。注意该区间是左闭右开的区间。
deque.assign(n,elem);  //将n个elem拷贝赋值给本身。
deque& operator=(const deque &deq);	//重载等号操作符 
deque.swap(deq);  // 将deque与本身的元素互换

deque.size();	 		 //返回容器中元素的个数

deque.empty();	  //判断容器是否为空

deque.resize(num);  	//重新指定容器的长度为num，若容器变长，则以默认值0填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

deque.resize(num, elem);  //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

deque.insert(pos,elem);  //在pos位置插入一个elem元素的拷贝，返回新数据							的位置。

deque.insert(pos,n,elem);  //在pos位置插入n个elem数据，无返回值。

deque.insert(pos,beg,end);  //在pos位置插入[beg,end)区间的数据，无返回值

deque.clear();	   //移除容器的所有数据

deque.erase(beg,end); //删除[beg,end)区间的数据，返回下一个数据的位置。

deque.erase(pos);   //删除pos位置的数据，返回下一个数据的位置。

for(deque<int>::iterator it = deqIntA.begin(); it!=deqIntA.end();){
		if(*it == 4){
            //接收-返回指向下一个位置的迭代器
			it = deqIntA.erase(it);
		}else {
			cout<<*it;
			cout<<" ";
			it++;
		}
	}

list同样采用模板类实现,对象的默认构造形式：list<T> listT;  如：

list<int> lstInt;       //定义一个存放int的list容器。

list<float> lstFloat;     //定义一个存放float的list容器。

list<string> lstString;    //定义一个存放string的list容器。

方式一：list(beg,end);   //将[beg, end)区间中的元素拷贝给本身。方式二：list(n,elem);    //构造函数将n个elem拷贝给本身。方式三：list(const list &lst); //拷贝构造函数。

方式一：list(beg,end);   //将[beg, end)区间中的元素拷贝给本身。

方式二：list(n,elem);    //构造函数将n个elem拷贝给本身。

方式三：list(const list &lst); //拷贝构造函数。

list.front();   //返回第一个元素。
list.back();  //返回最后一个元素。

list.begin();     //返回容器中第一个元素的迭代器。

list.end();      //返回容器中最后一个元素之后的迭代器。

list.rbegin();     //返回容器中倒数第一个元素的迭代器。

list.rend();     //返回容器中倒数最后一个元素的后面的迭代器。

list.cbegin();  //返回容器中第一个元素的常量迭代器。

list.cend();  //返回容器中最后一个元素之后的常量迭代器。

list.assign(beg,end);   //将[beg, end)区间中的数据拷贝赋值给本身。

list.assign(n,elem);  //将n个elem拷贝赋值给本身。

list& operator=(const list &lst);	//重载等号操作符。

list.swap(lst);  // 将lst与本身的元素互换。

ist.size();	  //返回容器中元素的个数

list.empty();	  //判断容器是否为空

list.resize(num);  //重新指定容器的长度为num，若容器变长，则以默认值0填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

list.resize(num, elem);  //重新指定容器的长度为num，若容器变长，则以elem值填充新位置。如果容器变短，则末尾超出容器长度的元素被删除。

list.insert(pos,elem);  //在pos位置插入一个elem元素的拷贝，返回新数据的位置。

list.insert(pos,n,elem);  //在pos位置插入n个elem数据，无返回值。

list.insert(pos,beg,end);  //在pos位置插入[beg,end)区间的数据，无返回值。

list.clear();		//移除容器的所有数据

list.erase(beg,end);  //**删除****[beg,end)**区间的数据，返回下一个数据的位置。

list.erase(pos);   //删除pos位置的数据，返回下一个数据的位置。

lst.remove(elem);  //删除容器中所有与elem值匹配的元素。

l list.reverse();   //反转链表，比如list包含1, 2, 3, 4, 5五个元素，运行此方法后，list就包含5, 4, 3, 2, 1元素。

set<int> setInt;        //一个存放int的set容器。

set<float> setFloat;      //一个存放float的set容器。

set<string> setString;     //一个存放string的set容器。

multiset<int> mulsetInt;       //一个存放int的multi set容器。

multiset<float> multisetFloat;    //一个存放float的multi set容器。

multiset<string> multisetString;   //一个存放string的multi set容器。

set(beg,end);   //将[beg, end)区间中的元素拷贝给本身。

set(const set &s); //拷贝构造函数。

multiset(beg,end);   //将[beg, end)区间中的元素拷贝给本身。

multiset(const multiset &s); //拷贝构造函数。

set(const set &st);		    //拷贝构造函数

set& operator=(const set &st);	//重载等号操作符

set.swap(st);				  //交换两个集合容器

set容器的insert的返回值是一个对组
pair<set<int>::iterator,bool >ret = s1.insert(5);
cout<<*(ret.first)<<endl;
cout<<ret.second<<endl;
first返回插入元素的迭代器,*它得到的就是这个数值

set.insert(elem);   //在容器中插入元素。

set.begin();     //返回容器中第一个数据的迭代器。

set.end();      //返回容器中最后一个数据之后的迭代器。

set.rbegin();     //返回容器中倒数第一个元素的迭代器。

set.rend();     //返回容器中倒数最后一个元素的后面的迭代器。

set.size();	//返回容器中元素的数目

set.empty();//判断容器是否为空

set.clear();		 //清除所有元素

set.erase(pos);   //删除pos迭代器所指的元素，返回下一个元素的迭代器。

set.erase(beg,end);	 //删除区间[beg,end)的所有元素，返回下一个元素的迭代器。

set.erase(elem);   //删除容器中值为elem的元素。

setInt是用set<int>声明的容器，假设它内部现已包含按顺序的1, 2, 3, 4, 5, 6元素。

set<int>::iterator itBegin=setInt.begin();

++ itBegin;

set<int>::iterator itEnd=setInt.begin();

++ itEnd;

++ itEnd;

++ itEnd;

setInt.erase(itBegin,itEnd);

//此时容器setInt包含按顺序的1, 4, 5, 6四个元素。

setInt.erase(setInt.begin());	

setInt.erase(5); 

setInt.clear();			//容器为空

set.find(elem);  //查找elem元素，返回指向elem元素的迭代器。
//find是否查找到元素，可以通过返回的迭代器和容器的end()方法进行比较。end()就相当于字符串结束符，返回最后一个元素后面位置的迭代器。


set.count(elem);  //返回容器中值为elem的元素个数。对set来说，要么是0，要么是1。对multiset来说，值可能大于1。

set.lower_bound(elem);  //返回第一个>=elem元素的迭代器。

set.upper_bound(elem);	  //  返回第一个>elem元素的迭代器。

set.equal_range(elem);		//返回multiset容器中与elem相等的上下限的两个迭代器。上限是闭区间，下限是开区间，如[beg,end)。这个函数返回两个迭代器，而这两个迭代器被封装在pair中。
 //例如 1 2 3 3 3 4 返回的是[3,6);

map<int,string>m1;
m1.insert(pair<int,string>(18,"xiaohua"));

map/multimap采用模板类实现，对象的默认构造形式：

map<T1,T2> mapTT; 

multimap<T1,T2>  multimapTT;  

如：

map<int, char> mapA;

map<string,float> mapB;

//其中T1,T2还可以用各种指针类型或自定义类型

map<int, string> m1;
m1.insert(pair<int, string>(18, "王小花"));
pair<map<int,string>::iterator,bool>ret = 	m1.insert(pair<int, string>(18, "李小花"));
if (ret.second == 1)
{
	cout << "成功啦" << endl;
}
else
{
	cout << "失败" << endl;
}

map.begin();  //返回容器中第一个数据的迭代器。

map.end();  //返回容器中最后一个数据之后的迭代器。

map.rbegin();  //返回容器中倒数第一个元素的迭代器。

map.rend();  //返回容器中倒数最后一个元素的后面的迭代器。

map<T1,T2,less<T1> >  mapA;  //该容器是按键的升序方式排列元素。未指定函数对象，默认采用less<T1>函数对象。

map<T1,T2,greater<T1>> mapB;  //该容器是按键的降序方式排列元素。

less<T1>与greater<T1>  可以替换成其它的函数对象functor。

可编写自定义函数对象以进行自定义类型的比较，使用方法与set构造时所用的函数对象一样。

map(const map &mp);		   //拷贝构造函数

map& operator=(const map &mp);	//重载等号操作符

map.swap(mp);				//交换两个集合容器	

map.size();	//返回容器中元素的数目

map.empty();//判断容器是否为空

map.clear();		//删除所有元素

map.erase(pos);	//删除pos迭代器所指的元素，返回下一个元素的迭代器。

map.erase(beg,end);//删除区间[beg,end)的所有元素	，返回下一个元素的迭代器。

map.erase(key);   //删除容器中key为key的对组,返回删除的对组个数，失败返回0

map.erase(key_type *first, key_type *last)  //删除数组指定的半闭半开的区间中 特定的key对应的所有队组
例如:
	int range[] = {1,2,3,4};

map.find(key);  查找键key是否存在，若存在，返回该键的元素的迭代器；若不存在，返回map.end();
//因为multimap中可以存在重复的键值，所以用循环迭代器查找的时候，可以输入具有相同键值的元素。
//例如
map<int, string>m1;
m1.insert(pair<int,string>(18, "sb"));
map<int, string>::iterator it = m1.find(18);
if (it != m1.end())
{
    cout << it->first << endl;
    cout << it->second << endl;
}//这个比count控制循环更灵活实用性更强



map.count(key);  //返回容器中键值为key的对组个数。对map来说，要么是0，要么是1;对multimap来说，值>=0。

map.lower_bound(keyElem);  //返回第一个key>=keyElem元素的迭代器。

map.upper_bound(keyElem);	  //  返回第一个key>keyElem元素的迭代器。

map.equal_range(keyElem);		//返回容器中key与keyElem相等的上下限的两个迭代器。上限是闭区间，下限是开区间，如[beg,end)。（multimap重复元素	）

最后一个的代码示例
multimap<int, string> mul1;
mul1.insert(pair<int, string>(1, "甲"));
mul1.insert(pair<int, string>(2, "乙"));
mul1.insert(pair<int, string>(2, "丙"));
mul1.insert(pair<int, string>(3, "丁"));
mul1.insert(pair<int, string>(4, "卯"));

//返回的是两个玩意，所以要对组接收
pair<multimap<int, string>::iterator,multimap<int, string>::iterator> RecvPari = mul1.equal_range(2);
if (RecvPari.first != mul1.end())//就相当于对组与对组对比
{
    //注意对应map的元素存放在对组中
    cout << (*RecvPari.first).second << endl;
}
if (RecvPari.second != mul1.end())
{
    //存放value在该对组的第二位
    cout << (*RecvPari.second).second << endl;
}
//输出乙和丁
return 0;

queue<int,list<int>>;

queue采用模板类实现，queue对象的默认构造形式：queue<T> queT; 如：
 
queue<int> queueInt;       //一个存放int的queue容器。

queue<float> queueFloat;   //一个存放float的queue容器。

queue<string> queueString;   //一个存放string的queue容器。

...				  
注意： 尖括号内还可以设置指针类型或自定义类型。

queue<int, list<int>> queueList; //内部使用list 来存储队列元素的queue 容器.

错误: queue<int, vector<int>> queueList; //内部不能使用vector来存储队列元素				

queue.push(elem);  //往队尾添加元素

queue.pop();    //从队头处移除队首元素

queue(const queue &que);		   //拷贝构造函数

queue& operator=(const queue &que);	//重载等号操作符

queue.back();  //返回最后一个元素

queue.front();  //返回第一个元素

可以通过这两个接口修改容器对应内容，因为返回的是引用
 
存放自定义对象的时候考虑queue.emplace

queue.empty();  //判断队列是否为空

queue.size(); 	   //返回队列的大小

priority_queue(int,vector<int>,greater<int>);//值越小优先级越大
priority_queue(int,deque<int>,greater<int>);//值越小优先级越大

stack采用模板类实现， stack对象的默认构造形式： stack <T> stkT;  

stack <int> stkInt;       //一个存放int的stack容器。

stack <float> stkFloat;   //一个存放float的stack容器。

stack <string> stkString;   //一个存放string的stack容器。		  

//尖括号内还可以设置指针类型或自定义类型。

stack.push(elem);  //往栈头添加元素

stack.pop();     //从栈头移除第一个元素

//例:
stack<int> stkInt;  
stkInt.push(1);
stkInt.push(2);
stkInt.pop();  
stkInt.push(3);
此时stkInt存放的元素是1, 3

stack(const stack &stk);		   //拷贝构造函数

stack& operator=(const stack &stk);	//重载等号操作符

stack.top();	 //返回最后一个压入栈元素
//返回的是引用可以修改值

stack.empty();  //判断堆栈是否为空

stack.size(); 	   //返回堆栈的大小

array采用模板类实现，array对象的默认构造形式(涉及非类型参数-数值类模板)

array<T，10>  arrT;  //10 为数值型模板参数

array<int, 6> a1;   //一个存放int的array容器

array<float, 6> a2;  //一个存放float的array容器

array<student, 6> a3; //一个存放student的array容器


array<int, 6> a1={1,2,3,4,5,6}; //定义时同时初始化

a2.assign(0);//改变原来array中的所有元素的值

array<int, 6> a1 = {1, 2, 3};

array<int, 6> a2 ;

array.size();	  //返回容器中元素的个数

array.max_size(); //返回容器中最大的元素个数，与size 等同

array.empty();  //判断容器是否为空

typename list<T>::const_iterator citor;