几种常见STL容器类操作

STL容器类主要分为两种，一种是序列容器类，包括vector，list，deque等。另外一种是关联式容器，主要map，set。在实际使用过程中，主要按照数据存储的场景来选择容器。

在实际使用时，如何选择这三个容器中哪一个，应根据你的需要而定，一般应遵循下面的原则：
  　　1) 如果你需要高效的随机存取，而不在乎插入和删除的效率，使用vector
  　　2) 如果你需要大量的插入和删除，而不关心随机存取，则应使用list
  　　3) 如果你需要随机存取，而且关心两端数据的插入和删除，则应使用deque

//============================================================================
// Name        : CTest.cpp
// Author      : @CodingGeek
// Version     : 1.0
// Copyright   : Your copyright notice
// Description : 几种常见的STL容器学习研究
//============================================================================

#include <iostream>
#include <set>
#include <map>
#include <list>
#include <vector>
#include <deque>
#include <string>
#include <algorithm>

using namespace std;

void operatorList(void)
{
    list<string> lst_str1;
    lst_str1.push_back("1001");
    lst_str1.push_back("1002");
    lst_str1.push_front("1003");
    lst_str1.push_front("1004");
    lst_str1.sort(greater<string>());
    list<string>::iterator lst_iter = lst_str1.begin();
    for (; lst_iter != lst_str1.end(); ++lst_iter)
    {
        cout << *lst_iter << endl;
    }
    cout << "*************************" << endl;
    lst_str1.sort(less<string>());

    for (lst_iter = lst_str1.begin();
            lst_iter != lst_str1.end();)
    {
        if (*lst_iter == "1001")
        {
            lst_iter = lst_str1.erase(lst_iter);
        }
        else
        {
            lst_iter++;
        }

    }

    lst_iter = lst_str1.begin();
    for (; lst_iter != lst_str1.end(); ++lst_iter)
    {
        cout << *lst_iter << endl;
    }

    cout << "*************************" << endl;

    list<string> lst_str2;
    lst_str2.push_back("1005");
    lst_str2.push_front("1007");
    lst_str2.push_back("1004");
    lst_str2.push_back("end");

    lst_str1.merge(lst_str2);
    lst_str1.sort(less<string>());

    for (list<string>::iterator iter = lst_str1.begin(); iter != lst_str1.end(); iter++)
    {
        cout << *iter << endl;
    }
    cout << "*************************" << endl;
}

//仿函数
struct compare
{
    bool operator()(string s1, string s2)
    {
        return s1 > s2;
    }
};


void operatorSet(void)
{
    set<string, compare> set_str;
    set_str.insert("1000");
    set_str.insert("1001");
    set_str.insert("1002");
    set_str.insert("1004");
    set_str.insert("1003");

    if (!set_str.insert("1005").second) //insert faild
    {
        cout << "insert not ok" << endl;
    }


    set<string>::iterator set_iter = set_str.begin();
    string temp = "1001";
    while (set_iter != set_str.end())
    {
        if(*set_iter == temp)
        {
            set_str.erase(set_iter++);
        }
        else
        {
            ++set_iter;
        }

    }


    for (set_iter = set_str.begin(); set_iter != set_str.end(); ++set_iter)
    {
        cout << *set_iter << endl;
    }
    cout << "***************************" << endl;
}

void operatorMap(void)
{
    map<string, string, compare> map_str;
    map_str.insert(make_pair("hunan", "changsha"));
    map_str.insert(make_pair("hubei", "wuhan"));
    map_str.insert(make_pair("henan", "zhenzhou"));
    map_str.insert(make_pair("guangdong", "guangzhou"));
    map_str.insert(make_pair("beijing", "beijing"));

    for (map<string, string>::iterator iter = map_str.begin();
            iter != map_str.end(); iter++)
    {
        cout << iter->first <<":" << iter->second << endl;
    }

    cout << "***************************" << endl;
    multimap<string, string, compare> mulmap_str;
    mulmap_str.insert(make_pair("hunan", "changsha"));
    mulmap_str.insert(make_pair("hubei", "wuhan"));
    mulmap_str.insert(make_pair("henan", "zhenzhou"));
    mulmap_str.insert(make_pair("guangdong", "guangzhou"));
    mulmap_str.insert(make_pair("hubei", "xianning"));

    for (map<string, string>::iterator iter = mulmap_str.begin();
            iter != mulmap_str.end(); iter++)
    {
        cout << iter->first <<":" << iter->second << endl;
    }
    cout << "***************************" << endl;
}

void operatorVector(void)
{
    vector<string> vec_str;
    vec_str.push_back("1002");
    vec_str.push_back("1007");
    vec_str.push_back("1006");
    vec_str.push_back("1005");
    vec_str.push_back("1000");
    sort(vec_str.begin(), vec_str.end(), greater<string>());

    vector<string>::iterator vec_iter = vec_str.begin();
    while (vec_iter != vec_str.end())
    {
        if (*vec_iter == "1005")
        {
            vec_iter = vec_str.erase(vec_iter);
        }
        else
        {
            ++vec_iter;
        }

    }


    vec_iter = vec_str.begin();
    while (vec_iter != vec_str.end())
    {
        cout << *vec_iter << endl;

        ++vec_iter;
    }

    cout << "***************************" << endl;
}

void operatorDeque(void)
{
    deque<int> de_str;
    de_str.push_back(11);
    de_str.push_front(14);
    de_str.push_back(13);
    de_str.push_back(15);
    de_str.push_front(10);

    deque<int>::iterator de_iter = de_str.begin();

    sort(de_str.begin(), de_str.end(),greater<int>());

    while (de_iter != de_str.end())
    {
        if (*de_iter % 2)
        {
            de_iter = de_str.erase(de_iter);
        }
        else
        {
            de_iter++;
        }


    }


    for (de_iter = de_str.begin(); de_iter != de_str.end(); ++de_iter)
    {
        cout << *de_iter << endl;
    }

    cout << "***************************" << endl;
}



int main()
{
    operatorList();
    operatorSet();
    operatorMap();
    operatorVector();
    operatorDeque();
    return 0;
}