STL容器：vector,list,deque 容器适配器：stack,queue关联容器：map set

STL容器

近容器：
string
int arr[ ]
顺序容器：无find();
vector ：一维数组自动按1.5倍扩容
list ：链表，每次申请一个结点
deque：双端队列（底层是二维数组）

容器适配器：无迭代器
stack------底层依赖deque
queue----底层依赖deque

关联容器：有迭代器
set（multiset）：集合 数据有序且去重 底层红黑树 增删改查快
map(multimap)：映射表（键值对） 数据按key有效(会按键排序) 红黑树 不允许重复

string

int main()
{
  string s;默认构造
  string s("pppp");构造
   string s1(s);拷贝构造
   string s2(s1.begain,s1.end());用迭代器构造s2
  s.push_back('a');尾插
  s.pop_back();尾删
  for(int i=0;i<s.size();++i)打印数据
  {
     if(s[i]=='b')
     {
         s[i]='y';
     }
     cout<<s[i]<<endl;
  }
  cout<<s.c_str<<endl;打印数据，但数据之间没有空格
  cin>>s;输入字符串
  cout<<s<<endl;输出字符串
  用迭代器来输出
  string::itreator it=s.begain();
  for(;it!=s.end();it++)
  {
     if(*it=='a')
     {
       it=s.inster(it,'m');插入m
       cout<<*it<<" ";m
       it++;
       
       it=s.erase(it);删除a
       
     }
      
      cout<<*it<<" ";
  }
  

   s.back();获取最后一个值
   s.front();获取第一个值
   s.empty();是否为空
   s.find('m');找到m返回下标，没找到返回-1
   s.find("efg")可以寻找子串，并返回第一个字母下标
   s.clear();清楚所有元素
   char err[10]={"abcdefg"};
   char* p=err; 
   s.copy(p,4);
   cout<<err<<endl;将s的前4个拷贝，剩下的不变err=ppppefg
   s.resize(4);扩大或缩小
   s.reserve(5)扩容，不给参数默认为0
   s.swap(s1);交换两个容器的数据
   
}

vector

vector：容器（数组）

resize:resize(n),减少或扩大到n个，不管有没有值

reserve:n大于本身的值就开辟到个空间，但size不会变，本身的值大于n,就不工作了，还是本身的值

pop_back():从尾出一个值

back()：取最后一个值

用模板实现vector的代码
template<typename T>

class Myvector
{
 private：
       T* _arr;
       int _len;
       int _val_len;
public:
     Myvector()
     {
        _arr=NULL;
        _len=0;
        _val_len=0;
     }   
Mvector(const Mvector& src)
{
  if(NULL==src._arr)
  {
     _arr=src._arr;
     _len=src._len;
     _val_len=src._val_len;
     
  }else
  {
     _len=src._len;
     _val_len=src._val_len;
     _arr=new T[_len];
     for(int i=0;i<_val_len;++i)
     {
         _arr[i]=src._arr[i];
     }
  }

}
~Mvector()
{
   delete[]_arr;
   _arr=NULL;
}
Mvector& operator(const Mvector& src)
{
   if(&src==this) return *this;
   if(NULL!=_arr)防止内存泄漏
   {
     delete[]_arr;
   }
   _len=src._len;
   _val_len=src._val_len;
   _arr=new T[_len];
   for(int i=0;i<_val_len;++i)
   {
        _arr[i]=src._len[i];
   }
}
void push_back(const T& val)
{
   if(full())
   {
     if(_len==0)
     {
     _len=1;
     }
       int len=_len<<1;
       reserve(len);
   }  
  _arr[_val_len]=val;
  _val_len++;
}

void pop_back()
{
    if(empty())
    {
      return;
    }
   _val_len--;
}

int size()const
{
   return _val_len;
}

void resize(int len)
{
   if(len<0)
   {
      len=0;
   }
   if(_len==0)
   {
      _len=0;
      _val_len=0;
      return;
   ]
   _arr=new T[len]();
   for(int i=0;i<len&&i<_val_len;++i)
   {
     arr[i]=_arr[i];
   }
   delete[]_arr;
   _val_len=len;
   _arr=arr;
}
void reserve(int len)
{
   if(len<_val_len)
   {
      return;
   }
   _len=len;
   T* arr=new[_len];
   for(int i=0;i<_val_len;++i)
   {
      arr[i]=_arr[i];
   }
   delete[]_arr;
   _arr=arr;
}
bool empty()const
{
   return _val==0;
}

T& operator[](int pos)
{
   return _arr[pos];
}
T operator[](int pos)const
{
    return _arr[pos];
}

}

vector的函数用法

vector<int> v;
for(int i=0;i<10;++i)
{
    v.push_back(i);尾插
}
v.pop_back();尾删
v.back();获取最后一个值
v.size();长度
v.max_size();当前内存里可以容纳的大小
v.swap(v1);交换两个容器的数据
v.front();输出第一个数据
v.clear()清除容器
v.empty();是否为空
v.  ();扩大或缩小
v.reserve();扩容
迭代器：
vector<int>::iterator it=v1.begain();
for(;it!=v1.end();++it)
{
   if(*it==5)
   {
     it=v1.insert(it,99);
     it++;
     ///
     it=v1.erase(it);
   }
   cout<<*it<<" ";
} 
用模板输出多个类型数据
template<typename CON>
void Show(CON& con)
{
   CON::iterator it=con.befain();
   for(;it!=con.end();it++)
   {
      cout<<*it<<" ";
   }
}这个函数可以打印vector,string...
二维vector:
vector<vector<int>>

list

list<int> L;
for(int i=0;i<10;++i)
{
   L.push_back(i); 尾插
}
用list的数据初始化vector
vector<int> v(L.begain(),L.end());
L.push_front(1);头插
L.pop_front();头删
L.resize(20);无reserve
L.reverse();翻转
L.push_back();尾插
L.pop_back();尾删
L.front();获取第一个值
L.back();获取最后一个值

deque

插入删除是重点，一个指针指向头，一个指针指向尾，头尾指针不确定在哪

stack

stack<int> s;
for(int i=0;i<10;++i)
{
   s.push();入栈
}
s.pop();出栈
s.top();获取栈顶元素
s.empty();判空
s.size();大小
s.swap(s1);交换两个栈的元素

queue

queue<int> q;
for(int i=0;i<10;++i)
{
   q.push(i);入队
}
q.pop();出队
q.front();获取第一个元素（队头）
q.back();获取队尾
q.size();
q.swap(q1);

set和multiset

虽然有迭代器但插入和删除不依靠它

set
#include<set>
set<int> s;
s.insert(56);插入
s.erase(56);删除
s.insert(23);会按照插入的数据排序，重复的去掉
set<int>::iterator it=s.find(23);找到返回迭代器，否则返回end
if(it!=s.end())
{
    cout<<*it<<endl;
}else
{
   cout<<"dont find"<<endl;  
}
s.clear();清除所有数据
s.cout(78);有几个78，1或0
s.empty()判空
s.size();长度
s.swap(s1);交换两个集合的数据
无扩容，翻转

multiset:排序但不去重

multiset<int> ms;
ms.insert(22);
ms.insert(11);
ms.insert(10);
ms.insert(22);
multiset<int>::iterator it1=ms.find(22);
if(it1!=ms.end())
{
  for(int i=0;i<ms.cout(*it);++i)cout()可以知道有多少个22，有几个就打印几个
  {
    cout<<*it1<<endl;
    it1++;
  } 
}else
{
   cout<<"dont find"<<endl;
}

map

#include<map>
map<int,string> mm;
mm.insert(make_pair(1,"aaaa"));
mm.insert(make_pair(3,"cccc"));
mm.insert(make_pair(5,"eeee"));
mm.insert(pair<int,string>(4,"dddd"));
map<int,string>::iterator it=mm.begain();
遍历
for(;it!=mm.end();++it)
{
   cout<<it->first<<" ";
   cout<<it->second<<" ";
}
 查找1
 map<int,string>::iterator it1=mm.find(5);
 if(it1!=mm.end())
 {
    cout<<it1->first<<" ";
    cout<<it1->second<<" ";
 }else
 {
   cout<<err;
 }
 查找2
 cout<<mm[4]<<endl;4为键
  mm.clear();
  mm.erase(5);
  mm.size();
  mm.cout(5);5的键值对有几个
   multimap可以重复
   multimap<int,string> mmm(mm.begain(),mm.end());可重复
   mmm.insert(make_pair(1,"aaaa"));
   mmm.insert(make_pair(3,"cccc"));
   mmm.insert(make_pair(5,"eeee"));