c++的STL中的容器使用

• vector:
  vector的数据结构和数组十分相似，称单端数组
  vector可动态扩展，而普通数组是静态空间
  动态扩展：找到更大的空间拷贝原数据到新空间，释放原空间
  vector的迭代器支持随机访问
  vector的函数原型：
  ·vector<T> v;//采用模板实现类实现，默认构造函数，无参构造 如：vector<int> v1;
  ·vector(v.begin(),v.end());//将v[begin(),end())区间的元素拷贝给本身
  如：vector<int>v2(v1.begin(),v1.end());
  ·vector(n,elem);//构造函数将n个elem拷贝给本身
  如：vector<int>v3(10,100);
  ·vector(const vector &vec);//拷贝构造函数
  如：vector<int> v4(v3);
  vector的赋值操作：
  函数原型：
  vector& operator=(const vector &vec);//重载等号操作符
  如：vector<int> v1; vector<int> v2; v2=v1
assign(beg,end)//将[beg,end)区间的数据赋值给本身
  如：vector<int> v3;v3.assign(v1.bengin,v1.end);
assign(n,elem)//将n个elem赋值给本身
  如：vector<int> v4(10,100);
  vector的容量和大小：
  函数原型：
  empty();//判断容器是否为空，返回bool值，为真则容器为空
  capacity（);//返回容器的容量
  size();//返回容器中元素的个数
  resize(int num);//重写容器的元素个数为num，如果写长，多出部分填默认值，写短删除超出长度数据
  resize（int n,elem）;//重写容器的元素个数为num，如果写长，多出部分填elem，写短删除超出长度数据
  vector的插入和删除：
  函数原型：
  push_back(ele);//尾部插入ele；
  pop_back();//删除最后一个元素；
  insert(const_iterator pos,ele)//迭代器指向位置pos插入元素ele；
  insert(const_iterator pos,int a,ele)//迭代器指向位置pos插入a个元素ele；
  earse（const_iterator pos)//删除迭代器指向位置pos的元素；
  earse(const_iterator start,const_iterator end);//删除迭代器从start到end之间的元素；
  clear();//删除容器中所有元素；
  vector的数据存取
  函数原型：
  at(int a);//返回索引a所指的数据；
  operator[a];//返回索引a所指的数据；
  front();//返回容器中第一个元素；
  back();//返回容器中最后一个元素；
  vector容器的互换
  swap(vec);//将vec与本身元素互换；
  如：vector<int>（ v）.swap(v);//该步骤创建了一个匿名对象vector<int>(v)与原容器v进行交换，匿名对象使用后被立即销毁，有时可以巧妙的收缩空间；
  vector预留空间
  减少vector的动态扩展次数
  reserve(int len);//容器预留len个元素长度的空间，预留位置不初始化元素；
• string
  string容器在c++中本质是一个类，是一个char*（指针）容器；
  string的构造原型
  string();//默认构造；
  string(const char* c)//将字符串c赋值给本身；
  string(const string& str);//拷贝构造；
  string(int a,const char c);//将a个c赋值给本身；
  string的赋值函数构造原型
  string& operator=(const char* c);//将字符串c赋值给当前字符串；
  string& operator=(char c);//将字符c赋值给当前字符串；
  string& operator=(const string& str);//将字符串str拷贝给当前字符串；
  string& assign(const char* c);//将字符串c赋值给当前字符串；
  string& assign(const char* c,int a);//将字符串c的前n个字符赋值给当前字符串；
  string& assign( char c);//将字符c赋值给当前字符串；
  string& assign(const string &str);//将字符串str赋值给当前字符串；
  string& assign(int n,char c);//将n个字符c赋值给当前字符串；
  string字符串拼接
  string& operator+=(const char* c);//将字符串c拼接到前字符串尾；
  string& operator+=(char c);//将字符串c拼接到当前字符串尾；
  string& operator+=(const string& c);//将字符串c拼接到当前字符串尾；
  string& append(const char* c);//将字符串c拼接到前字符串尾；
  string& append(const char* c，int a);//将字符串c的前a个字符拼接到前字符串尾；
  string& append(const string &c);//将字符串c拼接到前字符串尾；
  string& append(const string &c,int a,int b);//将字符串c从a（从0开始）位置的b个字符拼接到前字符串尾；
  string的查找和替换
  未找到返回-1，找到返回位置int（从0开始）
  int find(const string& str,int pos=0)const;//查找str第一次出现的位置，从pos开始查找；
  int find(const char* str,int pos=0)const;//查找str第一次出现的位置，从pos开始查找；
  int find(const char* str,int pos=0，int a)const;//查找str的前a个字母第一次出现的位置，从pos开始查找；
  int find(const char str,int pos=0)const;//查找str第一次出现的位置，从pos开始查找；
  rfind从右往左查找；
  string& replace(int pos,int a,const string& str)//pos开始的第a个字符替换为字符串str；
  string& replace(int pos,int a,const char * c)//pos开始的第a个字符替换为字符串c；
  字符串比较(ASCLL)
  = 返回0，<返回-1，>返回1
  int compare(const string& str);//int compare(const char* s)
  string字符存取
  char& operator[int a];//通过[]取字符；
  char& at(int a);//通过at；
  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 s)//在pos处插入n个字符s；
  string& earse(int pos,int n)//从pos处删除n个字符；
  string的子串获取
  string& substr(int pos,int n)const;//从pos处获取n个字符为子串；
• deque
  deque内部有个中控器，维护每段缓冲区的内容，缓冲区中存放真实数据，中控器是维护每个缓冲区的地址，使得deque像一片连续的空间
  deque的头部插入和删除会比vector快，但vector的元素访问速度会比deque快
  deque的构造函数
  deque<T> d;//默认构造；
  deque(beg,end);//将区间[beg，end）中的元素拷贝给本身；
  deque(n,elem);//将n个elem拷贝给本身；
  deque(const deque &d);//拷贝构造函数；
  deque的赋值
  deque& operator=(const deque &d);//重载等号；
  assign(n,elem);//将n个elem赋值给本身；
  assign(beg,end)//将区间[beg，end）的数据拷贝给本身；
  deque的大小操作
  deque.empty();//判断容器是否为空；
  deque.size();//判断容器中元素的个数；
  deque.resize(num);//重写容器的长度为num，若容器变长，则以默认值填充新位置，变短则删除末尾超出容器长度的数据；
  deque.resize(num，elem);//重写容器的长度为num，若容器变长，则以elem填充新位置，变短则删除末尾超出容器长度的数据；
  deque的插入和删除
  push_back(elem)//尾插elem；
  push_front(elem)//头插elem；
  pop_back()//尾删；
  pop_front()//头删；
  insert(pos,elem)//pos位置插入elem；
  insert(pos，n,elem)//pos位置插入n个elem；
  insert(pos,beg,end)//pos位置插入[beg,end)区间的数据；
  clear（）；//删除所有数据；
  earse(beg,end);//删除[beg,end)区间上的数据，返回下一个数据的位置
  earse(pos);//删除pos位置的数据，返回下一个数据的位置
  deque的存取
  at(int n);//返回索引n处的数据；
  operator[int n];//返回索引n处的数据；
  front();//返回容器中的第一个元素；
  back();//返回容器中的最后一个元素；
  deque的排序
  sort(iterator beg,iterator end);//对beg和end区间内元素进行排序
  #- stack
  stack是一种先进后出的数据接口，只有一个出口；只有栈顶元素允许被访问，因此不予许被遍历；
  stack构造函数
  stack<T> s;//模板构造；
  stack（const stack &k）;//拷贝构造；
  stack赋值
  stack & operator=(const stack & s)//重载拷贝
  stack数据存取
  push(elem);//向栈中插入elem；
  pop();//删除栈中第一个元素；
  top();//返回栈顶元素；
  stack大小操作
  empty（）;//判断是否为空；
  size（）;//返回栈的大小；
• queue
  queue是一种先进先出的数据结构，有两个出口；只有队头和队尾才能被外界访问，因此不允许被遍历；从一端进入数据（入队），另一端出数据（出队）；
  queue的构造函数
  queue<T> q;//默认构造；
  queue(const queue& q);//拷贝构造；
  queue的赋值
  queue operator=(const queue& q);//重载等号；
  queue的存取
  push(elem);//尾插elem；
  pop();//头删
  back();//返回最后一个元素；
  front();//返回第一个元素；
  queue的大小操作
  empty();//判断栈是否为空；
  size();//返回栈的大小；
• list
  链表是一种物理存储单元上的非连续结构，数据元素的逻辑顺序是通过链表中的指针链接实现的；链表由一系列结点组成；结点由一个存放数据元素的数据域和一个存放下一个结点地址的指针域组成；STL中的链表是一个双向循环链表；
  list的函数构造原型
  list<T> list;//默认构造；
  list（beg,end);//构造函数将[beg,end)区间元素拷贝给本身；
  list（n,elem);//构造函数将n个elem拷贝给本身；
  list（const list &l);//拷贝构造函数；
  list容器的赋值与交换
  assign(beg,end);将[beg,end)区间元素赋值给本身；
  assign(n,elem);//将n个elem拷贝赋值给本身；
  list& operator=(const list& l);//重载等号操作符；
  swap(list);//将list元素与本身互换；
  list的大小
  size();//返回容器中的元素个数；
  empty();//判断容器是否为空；
  resize(num);//重写容器的长度为num，若容器变长默认值填充，变短尾部超出长度的元素被删除；
  resize(num ，elem);//重写容器的长度为num，若容器变长elem填充，变短尾部超出长度的元素被删除；
  list容器的插入和删除
  push_back(elem);//尾插elem；
  push_back();//尾删；
  push_front(elem);//头插elem；
  pop_front();//头删；
  insert(pos,beg,end);//pos位置插入[beg,end)区间的元素，无返回值；
  insert(pos,elem);//pos位置插入元素elem，返回新数据的位置；
  insert(pos,n,elem);//pos位置插入n个元素elem，无返回值；
  clear();//移除容器所有元素；
  erase(beg,end);//删除[beg,end)区间的元素，返回下一个数据的位置；
  erase(pos);//删除pos处的元素，返回下一个数据的位置；
  remove(elem);//删除容器中所有与elem值匹配的元素；
  list函数的数据存取
  front();//返回第一个元素；
  back();//返回子最后一个元素；
  list的本质是链表，不是连续线性空间存储数据，故不支持随机访问；
  lsit容器中的反转和排序
  reverse();//反转链表表；
  sort();//链表排序；所有不支持随机访问迭代器的容器不可用标准算法，其内部会提供相应的算法；
  默认会是升序排列，这里可通过仿函数实现降序排列:bool fang(T a,T b) { return a>b; } sort(fang);
• set/multiset
  所有元素都会被自动排序；其本质为关联式容器，底层是用二叉树实现的；前者不可以插重复元素，后者可以插重复元素；
  set的构造函数和赋值
  set<T> s;//默认构造；
  set(const set & s);//拷贝构造；
  set operator(const set& s);//重载等号操作；
  set的大小和交换
  size();//返回容器的大小；
  empty();//判断容器是否为空；
  swap();//交换两容器的元素；
  set的插入和删除
  insert(elem);//插入元素elem，返回了一个对组:pair<iterator,bool>;,在multiset中返回了一个迭代器；
  clear();//删除所有元素；
  erase(beg,end);//删除[beg，end）区间的数据，返回下一个元素的迭代器；
  erase(pos);//删除pos位置的数据，返回下一个元素的迭代器；
  erase（elem);//删除其中值为elem的元素；
  set的查找和统计
  find(key);//查找元素key是否存在，存在返回该元素的迭代器，不存在则返回set.end();
  count(key);//统计key元素的个数；set中返回1和0；
  set容器排序更改
  利用仿函数实现降序排列：set<T,fang> s;//fang为仿函数；
  对于自定义的数据类型，利用仿函数指定排序规则；
• map/multimap
  map中每个元素都是pair，pair中的第一个元素为键值，启索引作用，第二个元素为实值，所有元素都会根据键值自动排序，其本质是关联式容器，底层结构是二叉树实现，可根据键值快速找到实值，前者不允许相同的键值，后者允许；
  map构造函数及赋值
  map<T1,T2>mp;//map默认构造函数；
  map（const map& mp);//map拷贝构造函数；
  赋值
  map& operator=(const map& mp);//map重载等号操作符；
  map容器的大小和交换
  size();//返回容器中元素的数目；
  empty();//判断是否为空；
  swap();//交换；
  map容器中元素的插入和删除
  insert(elem);//插入元素elem；
  例：map<int,int> m; //第一种方式： m.insert(pair<int,int>(1,10)); //第二种：m.insert(male_pair(2,10));//第三种：m.insert(map<int,int>::value_type(3,30));//第四种：m[4]=40;这种情况下如果只有键值会给实值附一个默认值
clear();//删除所有元素；
  erase(beg,end);//删除[beg，end）区间的数据，返回下一个元素的迭代器；
  erase(pos);//删除pos位置的数据，返回下一个元素的迭代器；
  erase（key);//删除其中值为key的元素；
  map的查找和统计
  函数原型：find(key);//查找key，存在返回该元素的迭代器，不存在返回map.end();
  count(key);//统计key的元素个数；
  map用仿函数可以改变排序规则；