c++中的容器类

https://blog.csdn.net/u014465639/article/details/70241850
一个容器就是一些特定类型对象的集合。主要包括顺序容器，关联容器和容器适配器。
顺序容器：各个元素之间有线性关系，元素排列次序与元素值无关，而与元素添加到容器里的次序有关。

关联容器：各个元素之间没有严格的物理上的顺序关系。与顺序容器根本的不同：关联容器中的元素是按照关键字来保存和访问的，而顺序容器中的元素是按照它们在容器中的位置来顺序保存和访问的。

容器适配器：本质上，适配器是使一种不同的行为类似于另一事物的行为的一种机制。适配器是容器的接口，它本身不能直接保存元素，可以把适配器看作“它保存一个容器，这个容器再保存所有元素”。STL 中包含三种适配器：栈stack 、队列queue 和优先级队列priority_queue 。

使用方法

顺序容器

1.vector(需要导入头文件#include < vector >)

//定义与初始化
vector<int> vec1;    //默认初始化，vec1为空
vector<int> vec2(vec1);  //使用vec1初始化vec2
vector<int> vec3(vec1.begin(),vec1.end());//使用vec1初始化vec2
vector<int> vec4(10);    //10个值为0的元素
vector<int> vec5(10,4);  //10个值为4的元素
vector<string> vec6(10,"null");    //10个值为null的元素
vector<string> vec7(10,"hello");  //10个值为hello的元素
//使用
vec1.push_back(100);            //添加元素
int size = vec1.size();         //元素个数
bool isEmpty = vec1.empty();    //判断是否为空
cout<<vec1[0]<<endl;        //取得第一个元素
vec1.insert(vec1.end(),5,3);    //从vec1.back位置插入5个值为3的元素
vec1.pop_back();              //删除末尾元素
vec1.erase(vec1.begin(),vec1.end());//删除之间的元素，其他元素前移
cout<<(vec1==vec2)?true:false;  //判断是否相等==、！=、>=、<=...
vector<int>::iterator iter = vec1.begin();    //获取迭代器首地址
vector<int>::const_iterator c_iter = vec1.begin();   //获取const类型迭代器
vec1.clear();                 //清空元素

int max=*max_element(a.begin().a,end()); //寻找最大值
int sum=accumulate(a.begin(),a.end(),0)//求和

2.list(需要导入头文件#include < list>)

//定义与初始化
list<int> lst1;          //创建空list
list<int> lst2(3);       //创建含有三个元素的list
list<int> lst3(3,2); //创建含有三个元素的值为2的list
list<int> lst4(lst2);    //使用lst2初始化lst4
list<int> lst5(lst2.begin(),lst2.end());  //同lst4
//操作
lst1.assign(lst2.begin(),lst2.end());  //分配值
lst1.push_back(10);                    //添加值
lst1.pop_back();                   //删除末尾值
lst1.begin();                      //返回首值的迭代器
lst1.end();                            //返回尾值的迭代器
lst1.clear();                      //清空值
bool isEmpty1 = lst1.empty();          //判断为空
lst1.erase(lst1.begin(),lst1.end());                        //删除元素
lst1.front();                      //返回第一个元素的引用
lst1.back();                       //返回最后一个元素的引用
lst1.insert(lst1.begin(),3,2);         //从指定位置插入3个值为2的元素
lst1.rbegin();                         //返回第一个元素的前向指针
lst1.remove(2);                        //相同的元素全部删除
lst1.reverse();                        //反转
lst1.size();                       //含有元素个数
lst1.sort();                       //排序
lst1.unique();                         //删除相邻重复元素

3.deque(需要导入头文件#include < deque>)
deque容器类与vector类似，支持随机访问和快速插入删除，它在容器中某一位置上的操作所花费的是线性时间。与vector不同的是，deque还支持从开始端插入数据：push_front()。其余类似vector操作方法的使用。

总结：




4.string

//定义与初始化
 string s1;
 string s2 = "c plus plus";
 string s3 = s2;
 string s4 (5, 's');
 int len = s.length(); //与C风格的字符串不同，string 的结尾没有结束标志'\0',因此为真实长度
 //转char
 const char*=path.c_str()
 //输入输出
string s;
cin>>s;  //输入字符串
out<<s<<endl;  //输出字符串
//插入
string s1, s2, s3;
s1 = s2 = "1234567890";
s3 = "aaa";
s1.insert(5, s3);//12345aaa67890
//删除
s1 = s2 = s3 = "1234567890";
s2.erase(5); //12345
s3.erase(5, 3); //1234590
//去掉首尾空格
str.erase(0,str.find_first_not_of(" "));//find_first_of() 函数用于查找子字符串和字符串共同具有的字符在字符串中首次出现的位置。请看下面的代码：
str.erase(str.find_last_not_of(" ") + 1);
//提取
string s1 = "first second third";
string s2;
s2 = s1.substr(6, 6); //second
//find
string strOutput = "|0|1|2|";
string strObj = "|1|";
size_t nLoc = strOutput.find(strObj);
if (nLoc != string::npos)
{cout << "nLoc is: " << nLoc << endl;}
//int转string
int nNum2 = 456;
string strTest4;
strTest4 = to_string(nNum2);
//string转int
char* s = "1234";
string str("5678");
int intS = atoi(s); //此写法会报错,int intStr = atoi(str);需先将string转成char*
int intStr = atoi(str.c_str())
//判断是否为数字
str[0]<'0'||str[0]>'9';//不是
isdigit(str[i])；//是的话返回true

关联容器

1.map(需要导入头文件#include < map>)
map提供一个key-value，可使用键作为下标来获取一个值。Map会根据key自动排序。multiple允许一个键对应多个值。
对于键类型，唯一的约束就是必须支持 < 操作符，至于是否支持其他的关系或相等运算，则不作要求。

//定义与初始化
map<int,string> map1;                  //空map
//插入元素
map1[3] = "Saniya";                    //添加元素
map1.insert(map<int,string>::value_type(2,"Diyabi"));//插入元素
map1.insert(pair<int,string>(1,"Siqinsini"));
map1.insert(make_pair<int,string>(4,"V5"));
string str = map1[3];                  //根据key取得value，key不能修改
map<int,string>::iterator iter_map = map1.begin();//取得迭代器首地址
int key = iter_map->first;             //取得key
string value = iter_map->second;       //取得value map1.erase(iter_map);                  //删除迭代器数据
map1.erase(3);                         //根据key删除value
map1.size();                       //元素个数
map1.empty();                       //判断空
map1.clear();                      //清空所有元素

map中使用下标存在一个很危险的副作用：如果该键不在 map 容器中，那么下标操作会插入一个具有该键的新元素。所以map 容器提供了两个操作：count 和 find，用于检查某个键是否存在而不会插入该键。


2.set(需要导入头文件#include < set>)
set是一个集合，是一个有序的容器。所有的操作的都是严格在logn时间之内完成，效率非常高。set和multiset的区别是：set插入的元素不能相同，但是multiset可以相同。Set默认自动排序。使用方法类似list。
set不提供下标操作。

//定义和初始化
vector< int > ivec; //利用数组
for  (vector< int >::size_type i = 0; i != 10; ++i) {
	ivec.push_back(i);
	ivec.push_back(i);
}
set< int > iset(ivec.begin(), ivec.end());
cout << ivec.size() << endl;  //20个
cout << iset.size() << endl;  // 10个
//添加元素
set<string> set1;
set1.insert( "the" );  //第一种方法：直接添加
set< int > iset2;
iset2.insert(ivec.begin(), ivec.end()); //第二中方法：通过指针迭代器
//获取元素
set< int > iset;
for ( int  i = 0; i<10; i++)iset.insert(i);
set.find(1)  // 返回指向元素内容为1的指针
set.find(11)  // 返回指针iset.end()
set.count(1)  // 存在，返回1
set.count(11)  // 不存在，返回0
//删除元素
set.erase(it);//删除迭代器指向的元素
set.erase(key);//删除指定值

存储方式

vector：相当于数组，但可不指定大小并可动态扩展。在创建一个vector 后会自动在内存中分配一块连续的内存空间进行数据存储，初始的空间大小可以预先指定也可以由capacity （）函数指定。当存储的数据超过分配的空间时vector 会重新分配一块内存块，但这样的分配是很耗时的。
deque：采用多个连续的存储块，并且在一个映射结构中保存对这些块及其顺序的跟踪。向deque 两端添加或删除元素的开销很小，它不需要重新分配空间。
list：是一个线性链表结构，它的数据由若干个节点构成，每一个节点都包括一个信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。它无需分配指定的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中。
set, multiset, map, multimap 是一种非线性的树结构，具体的说采用的是一种比较高效的特殊的平衡检索二叉树—— 红黑树结构。

优劣分析

其它

1.hashtable,hashset,hashmap,unordered_map、unordered_set与set,map的根本区别在于底层的实现不同，前者底层都是由hashtable来提供的，后者都是由红黑树来提供；前者查询时间虽然是O（1），但是并不是前者查询时间一定比后者短，因为实际情况中还要考虑到数据量，而且前者的hash函数的构造速度也没那么快，所以不能一概而论，应该具体情况具体分析。后者保证了一个稳定的动态操作时间，查询、插入、删除都是O（logN），最坏和平均都是。
2.unordered_map、unordered_set在C++11的时候被引入标准库了，而hashset,hashmap没有，所以建议还是使用unordered_map比较好。
3.hashset与set相比较，它里面的元素不一定是经过排序的，而是按照所用的hash函数分派的，它能提供更快的搜索速度（当然跟hash函数有关）。（hashmap与map区别一样）
4.后面有时间再写