1.C++中的STL容器可以分为三大类：顺序容器，关联容器，容器适配器。

2.顺序容器（线性表）：

　　vector:后部插入/删除数据，直接访问（顺序存储）

#include <iostream>
#include <vector>

using namespace std;

void show(vector<int> &numbers)
{
    for(int i=0;i<numbers.size();i++)
    {
        cout<<numbers.at(i)<<" ";
    }
    cout<<endl;
}

int main()
{
    //创建vector对象
    vector<int> numbers;
    //插入5个123到vector容器中
    numbers.assign(5,123);
    show(numbers);

    //插入321到vector对象的末尾，只能插入一个，而不能一次性插入多个
    numbers.push.back(321);
    show(numbers);

    //删除容器最末尾的一个成员
    numbers.pop.back();
    show(numbers);

    //在指定的位置插入成员
    //使用迭代器，让it指向vector的开头，即第一个成员的前面
    vector<int>::iteratir it=numbers.begin();
    //在第一个成员后面插入一个成员
    numbers.insert(++it,999);
    show(numbers);

    //此时it已经指向vector的第一个成员的后面，要在最前面插入成员，只有--it
    numbers.insert(--it,888);
    show(numbers);

    //迭代器遍历数据
    it=numbers.begin();
    for(;it<numbers.end();it++)
    {
        cout<<*it<<" ";
    }
    cout<<endl;

    //查找vector中的数据（999）----遍历
    it=numbers.begin();
    for(;it!=begins.end();it++)
    {
        if(*it == 999)
        {
            cout<<"found"<<endl;
            break;
        }
    }

    //获取容器vector容器所能占用的最大空间
    cout<<numbers.max_size();
    return 0;
}

 

　　dequeue：前/后部插入/删除数据，直接访问

 

　　list：双向链表，任意位置插入/删除数据（双向循环链表）

#include <iostream>
#include <list>

using namespace std;

class Data{
public:
    Data(int d=0):data(d){}
    ~Data(){}
    void setData(int data){this->data==data;}
    int getData()const{return this->data;}
    bol operator==(Data d)//重载“==”，“<”运算符，这两个运算符在stl中经常重载
    {
        if(this->data==d.data)
        {
            return true;
        }else{
            return false;
        }
    }

    //重载"<"运算符
    bool operator<Data &d>
    {
        if(this->data<d.data)
        {
            return true;
        }else{
            return false;
        }
    }
protected:
        int data;
}

void show(list<Data> &ldata)
{
    //迭代器 让it指向list的最前面
    list<Data>""iterator it=ldata.begin();
    for(;it!=ldata.end();++it)
    {
        cout<<(*it).getData()<<" ";
    }
    cout<<endl;
}

//自定义排序算法
bool conpare_nocase(const Data& first,const Data& second)
{
    if(first.getData()<<second.getData())return false;
    eles return true;
}

int main()
{
    //创建链表，存储Data数据
    list<Data> ldata;

    //创建一个数据对象
    Data md1=123;
    //插入队列并显示
    ldata.assign(1,md1);
    show(ldata);

    //在最前面，插入数据并显示
    list<Data>::iterator it=ldata.begin();
    Data md2=25;
    ldata.insert(it,md2);
    show(ldata);

    //分别在最前面和最后面插入数据
    Data md4=33;
    ldata.push_front(md4);
    show(ldata);
    Data md3(22);
    ldata.push_back(md3);
    show(ldata);

    //删除最前面的数据
    ldata.erase(ldata.begin());
    show(ldata);
    //删除指定的数据，要知道该数据的变量名
    ldata.removr(md3);
    show(ldata);

    //链表翻转输出，这里用的是"rbegin"和"rend"
    list<Data>::reverse_iterator lt=ldata.rbegin();
    for(;lt<ldata.rend();++lt)
    {
        cout<<(*lt).getData()<<" ";
    }
    cout<<endl;

    //队列排序，从小到大
    ldata.sort(compare_nocase);
    show(ldata);
    return 0;
}

 

2.关联容器

　　set：快速查找，无重复元素

#include <iostream>
#include <set>

using namespace std;

int main()
{
    //讲一个int型数据与一个string型数据组合成一个数据
    std::pair<int,string> info;
    info.first=100;
    info.second="hello";

    //创建set容器对象，内容不能重复
    set<string> usernames;
    std::Pair<set<string>::iterator,bool>;
    ret=usernames.insert("aack");
    if(!ret.second)
    {
        cout<<"0-insert fail"<<endl;
    }

    cout<<usernames.size()<<endl;

    //插入数据
    ret=usernames.insert("cose");
    if(!ret.second)
    {
        cout<<"1-insert fail"<<endl;
    }

    ret=usernames.insert("bom");
    if(!ret.second)
    {
        cout<<"2-insert fail"<<endl;
    }

    //遍历输出
    set<string>::iterator it=usernames.begin();
    for(;it!=usernames.end();++it)
    {
        //输出存在容器中的数据
        cout<<*it<<" ";
    }
    cout<<endl;

    //查找数据
    it=usernames.find("bom");
    //如果找到数据，it就指向数据的位置，不然就指向结尾
    if(it==usernames.end())
    {
        cout<<"not found"<<endl;
    }else{
        cout<<*it<<endl;
    }

    //删除数据，通过迭代器删除
    usernames.erase(it);
    //通过元素进行删除
    usernames.erase("ack");

    return 0;
}

 

　　multiset：快速查找，可有重复元素

#include <iostream>
#include <set>

using namespace std;

int main()
{
    //创建multiset容器
    multiset<int> numbers;
    //插入数据
    numbers.insert(5);
    cout<<numbers.size()<<endl;
    //multiset可以插入相同的数据,set则不行
    numbers.insert(5);
    cout<<numbers.size()<<endl;

    //输出multiset中元素"5"总共有多少个
    cout<<numbers.cout(5)<<endl;

    //遍历
    multiset<int>::iterator it=numbers.begin();
    for(;it!=numbers.end;++it)
    {
        cout<<*it<<" ";
    }
    cout<<endl;
    return 0;

}

 

　　map：一对一映射，无重复元素，基于关键字查找

#include <iostream>
#include <map>

using namespace std;

int main()
{
    //创建容器对象
    map<string,string> upass;
    //插入数据 upass[key]=value,key是唯一的，value任意
    upass["aaa"]="123456";
    upass["aaa"]="222222";
    //第一次的值会被第二次的覆盖掉
    upass["ccc"]="333333";

    //插入数据，通过std::pair打包
    std::pair<string,string> data;
    data.first="aaa";
    data.second="222222";
    upass.insert(data);

    //遍历
    cout<<upass["aaaa"]<<endl;
    map<string,string>::iterator it=upass.begin();
    for(;it!=upass.end();++it)
    {
        cout<< it->first <<" "<< it->second<<endl;
        //it得到的是std::pair<string,string>
    }

    //查找
    map<string,string> pvs;
    pvs["ai"]="爱哎碍唉";
    pvs["a"]="啊阿吖锕";
    string pingyin;
    cout<<pvs[pingyin]<<endl;

    return 0;
}

 

　　multimap：一对一映射，可有重复元素，基于关键字查找。

 

3.容器适配器

　　stack:FILO（先进后出）

 

　　queue：FIFO

#include <iostream>
#include <queue>

using namespace std;

int main()
{
    std::queue<string> names;
    //往容器（队列)中插入数据,数据从尾部插入，不允许相同，相同的数据只会插入一个
    names.push("jack");
    names.push("rose");
    names.push("tom");

    //输出第一个和最后一个
    cout<<names.front()<<" "<<names.back()<<endl;

    //遍历数据
    while(1)
    {
        cout<<names.front()<<" ";
        //删除第一个数据
        names.pop();
        if(names.size()==0)break;
    }
    return 0;
}

 

 

PS：有哪里错漏的，请指正，互相学习。