标签：
1.vector：
#include <vector>
#include <algorithm>
vector<int> v;
vector<int> v(10);//定义大小为10的int型向量容器。
vector<int> v(10,3);//定义大小为10，每个元素为3。
v.push_back(2);//尾部添加元素2.
v[0]=2;
v[1]=3;//下标访问。
vector<int>::iterator it;//迭代器访问
for(it=v.begin();it!=v.end();it++)
{
cout<<*it<<" ";
}
//元素插入，插入位置必须是迭代器位置
v.insert(v.begin(),8);//最前面插入
v.insert(v.begin()+2,8);
v.insert(v.end(),8);//末尾追加
//元素删除
v.erase(v.begin()+2);//删除第2+1个元素
v.erase(v.begin()+1,v.begin()+5);//删除迭代器第一到第五区间的所有元素
v.clear();//删除所有元素
reverse(v.begin(),v.end());//反向排列向量所有元素（可以反向排列某段迭代器区间元素）
sort(v.begin(),v.end());//sort排序（默认升序排列）
//设计排序比较函数
bool comp(const int& a,const int& b)
{
return a>b;//降序排列
}
sort(v.begin(),v.end(),comp);
v.size();//返回向量大小,即元素个数
v.empty();//判空，空时返回1，不空时返回0。
2.string：(比较常用，暂且放这里）
#include <string>
#include <algorithm>
string s;//创建
s="I love you.";
char ss[5000];
s=ss;
s+=‘a‘;//尾部添加char字符
s+="abc";<=>s.append("abc");//尾部添加字符串
string::iterator it;//迭代器
it=s.begin();
s.insert(it+1,‘p‘);//将p插入到第1+1个字符前
s[0];//访问元素
s="";//清空字符串
string::iterator it=s.begin();
s.erase(it+3);//删除第3+1个元素
s.erase(it,it+4);//删除0~4区间元素
s.length();//返回字符串长度
s.empty();//判空
s.replace(3,2,"good");//从第3+1个字符起，把连续的2个字符替换为“good”
//find()可查找字符串中第一次出现的字符或子串，查到则返回下标值（0起），否则返回4294967295.
s.find(‘c‘);
s.find("c");
s.find("cat");
//比较字符串
s="cat dog cat";
s.compare("cat");//比cat大，返回1
s.compare("cat dog cat");//相等，返回0
s.compare("dog");//比dog小，返回-1
//reverse使得迭代器指向的某段区间元素反向排列
reverse(s.begin(),s.end());
//string作为vector元素
v.push_back("lvhuan");
cout<<v[0];
cout<<v[1].length();
//用printf输出字符串对象，要采用c_str()
printf(s.c_str());
//string对象与数值相互转换
#include <iostream>
#include <string>
#include <sstream>
using namespace std;
//C++方法：将数值转换为string
string convertToString(double x)
{
ostringstream o;
if(o<<x)
return o.str();
return "conversion error";//if error
}
//C++方法：将string转换为数值
double convertFromString(const string &s)
{
istringstream i(s);
double x;
if(i>>x)
return x;
return 0.0;//if error
}
int main()
{
//将数值转换为string的第一种方法：c方法
char b[10];
string a;
sprintf(b,"%d",1975);
a=b;
cout<<a<<endl;
//将数值转换为string的第二种方法：C++方法
string cc=convertToString(1976);
cout<<cc<<endl;
//将string转换为数值的方法：C++方法
string dd="2006";
int p=convertFromString(dd)+2;
cout<<p<<endl;
return 0;
}
3.stack：
//堆栈容器
stack<int> s;
s.push(1);//入栈
s.pop();//出栈
s.top();//返回栈顶元素
s.size();//返回元素个数
s.empty();//判空
4.queue：
//队列容器
//只能从队尾插入元素，队首删除元素
queue<int> q;
q.push(1);//入队
q.pop();//出队
q.front();//返回队首元素
q.back();//返回队尾元素
q.size();//返回元素个数
q.empty();//判空
5.priority_queue：
//优先队列容器
//只能从队尾插入元素，队首删除元素
//队列中最大的元素总是位于队首（默认从大到小排序，自己可以自定义比较函数来修改）
priority_queue<int> pq;
pq.push(1);//入队
pq.pop();//出队
pq.top();//返回队首元素
pq.size();//返回元素个数
pq.empty();//判空
//自定义比较函数
元素为结构体：
struct info
{
string name;
float score;
bool operator < (const info &a) const
{
return score>a.score;//从小到大（注意这次的符号）
}
}；
元素非结构体：
struct mycomp
{
bool operator () (const int &a,const int &b) const
{
return a>b;//从小到大（注意这次的符号）
}
};
priority_queue<int,vector<int>,mycomp> pq;//显示说明其内部结构是vector.（注意：当有自定义比较函数时，必须显示说明其内部结构是vector！）
6.deque：
创建
deque<int> d;
deque<int> d(10);//容量为10
deque<int> d(10,8.5);//10个并初始化为8.5
插入：
push_back()尾部插入，扩张队列
push_front()头部插入，不扩张队列，往后挤，把尾部的元素挤出去了
以上两个参数是一个元素对象
insert()中间某位置插入元素，不扩张队列，仍是挤出尾部的元素
参数为两个：迭代器位置+元素对象
eg：d.insert(d.begin()+1,88);//即插入到第二个位置，后面的往后顺延，最后一个丢失
遍历：
d[i]//数组方式
deque<int>::iterator it;
for(it=d.begin();it!=d.end();it++)
{
cout<<*it<<" ";
}//前向迭代器方式
deque<int>::reverse_iterator it;
for(rit=d.rbegin();rit!=d.rend();rit++)
{
cout<<*rit<<" ";
}//反向迭代器方式
删除：
首部：d.pop_front();
尾部：d.pop_back();
中间：d.erase(d.begin()+1);
清空：d.clear();
7.set：
#include <set>
#include <algorithm>
//不会重复插入相同键值的元素
//采用红黑树的平衡二叉检索树结构，中序遍历
set<int> s;
s.insert(3);//默认从小到大插入
set<int>::iterator it;
for(it=s.begin();it!=s.end();it++)
{
cout<<*it<<" "；
}
//反向遍历
set<int>::reverse_iterator rit;//反向迭代器
for(rit=s.rbegin();rit!=s.rend();rit++)
{
cout<<*rit<<" ";
}
//元素删除，删除对象可以是某个迭代器位置上的元素、等于某键值的元素、一个区间上的元素
s.erase(s.begin+1);
s.erase(6);
s.erase(s.begin(),s.begin()+4);
s.clear();
s.size();
s.find(6);//查找键值6，查到了则返回其迭代器位置，否则返回最后一个元素后面的位置，即end()
set<int>::iterator it;
it=s.find(6);
if(it!=s.end())
cout<<*it<<endl;
//自定义比较函数 默认从小到大存储
//非结构体元素
struct comp
{
bool operator () (const int& a,const int& b) const
{
return a>b;//从大到小
}
}
set<int,comp> s;//创建
set<int,comp>::iterator it;
其他操作一样
//结构体元素
struct info
{
string name;
float score;
bool operator < (const info &a) const
{
return score>a.score;//从大到小
}
}
set<info> s;//创建
set<info>::iterator it;
8.multiset：
#include <set>
#include <algorithm>
//允许重复的元素键值插入
//在插入，删除，查找方面与<set>有区别
multiset<string> ms;
ms.insert("abc");
multiset<string>::iterator it;
//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数）。
ms.erase("123");
ms.clear();
//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()
it=ms.find("123");
9.map：
#include <map>
#include <algorithm>
//不会重复插入相同键值的元素
//采用红黑树的平衡二叉检索树结构，中序遍历
//比较函数只对键值进行比较
//和set使用大都相同
map<string,float> m;
m["jack"]=98.5;//插入元素
m.insert(pair<string,float>("lvhuan",18.5));
map<string,float>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;//输出键值与映照数据
}
//可以删除某个迭代器位置元素、等于某键值的元素、某迭代器区间的所有元素
m.erase(4);
m.clear();
//反向遍历
map<string,float>::reverse_iterator it;
for(it=m.rbegin();it!=m.rend();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;//反向输出键值与映照数据
}
//find()返回键值所处迭代器位置或end()位置
//自定义比较函数（默认从小到大）
非结构体元素
struct comp
{
bool operator () (const int &a,const int &b) const
{
return a>b;//从大到小
}
}
map<int,char,comp> m;
map<int,char,comp>::iterator it;
结构体元素
struct info
{
string name;
float score;
bool operator < (const info &a) const
{
return score>a.score;//从大到小
}
}
map<info,int> m;//创建
map<info,int>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).second<<":";
cout<<((*it).first).name<<" "<<((*it).first).score<<endl;
}
10.multimap：
#include <map>
#include <algorithm>
//允许重复插入相同键值的元素
multimap<string,float> m;
m["jack"]=98.5;//插入元素
m.insert(pair<string,float>("lvhuan",18.5));
multimap<string,float>::iterator it;
for(it=m.begin();it!=m.end();it++)
{
cout<<(*it).first<<":"<<(*it).second<<endl;//输出键值与映照数据
}
//erase()可以删除某个迭代器位置的元素，某段区间的元素，键值等于某个值的所有重复元素（并返回删除元素个数），还有清空clear()
//find()，如果查到，返回该元素第一次出现的迭代器位置，否则返回end()
it=m.find("123");
11.list：
//双向循环链表容器
//迭代器只能使用“++”或“--”，不能使用“+n”或“-n”。
创建：
list<int> l;
list<int> l(10);//容量10
插入，都会自动扩张：
尾部：push_back()
首部：push_front()
中间：只能插到迭代器位置处：l.insert(it,20);//元素对象为20
遍历：
list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}//前向迭代器方式
list<int>::reverse_iterator it;
for(rit=l.rbegin();rit!=l.rend();rit++)
{
cout<<*rit<<" ";
}//反向迭代器方式
删除：remove()删除一个元素值，值相同的元素都会被删除。
l.remove(1);//删除值为1的所有元素
l.pop_front();//删除首部元素
l.pop_back();//删除链表尾部元素
list<int>::iterator it;
for(it=l.begin();it!=l.end();it++)
{
cout<<*it<<" ";
}
it=l.begin();
it++;
it++;
l.erase(it);//删除迭代器位置元素
l.clear();//清空
查找：find()，找到则返回迭代器位置，否则返回end().
eg:it=find(l.begin(),l.end(),5);//查找这个区间上的值为5的元素的位置
升序排序：
l.sort();
删除连续重复元素,只保留一个：
l.unique();//注意是删除连续重复，不是单单重复
12.bitset：
//bit位元素的序列容器，每个元素只占一个bit位，取值0或1.
/*
bitset类
方法列表：
b.any() b中是否存在置为1的二进制位？
b.none() b中不存在置为1的二进制位吗？
b.count() b中置为1的二进制位的个数
b.size() b中二进制位的个数
b[pos] 访问b中在pos处的二进制位
b.test(pos) b中在pos处的二进制位是否为1？
b.set() 把b中所有二进制位都置为1
b.set(pos) 把b中在pos处的二进制位置为1
b.reset() 把b中所有二进制位都置为0
b.reset(pos) 把pos处的二进制位置为0
b.flip() 把b中所有二进制位取反
b.flip(pos) 把pos处的二进制位取反
b.to_ulong() 用b中同样的二进制位返回一个unsigned long值
os<<b 把b中的位集输出到os流
*/
//创建
bitset<100000> b;//创建时必须指定容器大小，且不能再修改大小。默认初始值为0.
//元素赋值
b[6]=1;//下标法，最低位为第0位
b.set();//全部置1
b.set(6);//将指定位置1
b.reset();//全部置0
b.reset(6);//指定位置0
//输出元素
cout<<b[i];//下标法输出，可以借用b.size()来控制个大规模输出
cout<<b;//注意输出的可是二进制形式哦（01串）
标签：
原文地址：http://www.cnblogs.com/jiu0821/p/4190026.html
