STL概览

在进入STL的世界之前，我们先对其中的主要组件做一个鸟瞰：
先来一张层次图：

如果觉得层次图看不清的话，我们把它重新绘成思维导图吧：

从图中我们可以看到：
STL的核心只有三个大组件：

• 容器
• 迭代器
• 算法

当然，这么大的一个包罗万象的C++标准库，还是有很多其他的组件，比如智能指针、字符串、正则表达式、流式I/O、并发处理等不是跟容器相关的。但是做为核心的容器库，就只有这三大组件。

容器的种类其实蛮少的，大体上分为基本容器和特殊容器两大类。
基本容器按照无序，有序，排序分成了三大类：

• 有序是需要排照一定的顺序访问，比如数组和链表，但是并没有根据元素的值进行排序。这样的容器只有5个：array数组，vector动态数组，deque两端都可插入的动态数组，list双向链表，forward_list单向链表。
• 排序是经过比较和排序算法处理之后的针对值也有序的结果。一共有4个，set集合，multiset值可重复集合，map不重复的键-值对，multimap键值可重复的map. 排序结构一般用排序二叉树等结构来实现。
• 无序就是我们根本不关心元素的顺序，我们只关心是否放到容器中了。unordered set才是我们心目中的集合，不用加元素就排序。unordered multiset可以放多次。unordered map可以用作哈希表。unordered multimap可以用作字典。

只有上面13种基本容器，还是非常简单的。比起Java来，功能上还是有所欠缺的，比如Java中有对于并发支持比较好的ConcurrentHashMap，CopyOnWriteArrayList等的复杂性就不是这些容器所能比的。相比来说，C++ STL中的容器还处于初级阶段。

所谓迭代器，大家都熟悉迭代模式，就是遍历容器元素的方法。最简单的用法就像是指针一样，用*运算符取内容，++移至下一项，=赋值，==和!=判断是否相等。多出的begin()和end()是因为容器的访问需要一个头和尾。cbegin()和cend()是C++11新引入的，用于常量表示的头和尾。

最后是各种算法，小到计数，赋值，大到所有元素排序。看起来不少，但是都是实际对容器操作用得上的，所以其实也并不多。

容器概览

就是个数组 - array

array在TR1才被加入到STL的大家庭中。其实它本质上就是个数组，无法增加新成员，只能修改现有的成员的值。C++11为array带来的就是可以支持统一初始化，我们来看一个例子：

    std::array<std::string, 5> sequence_container = {"array","vector","deque","list","forward_list"};
    std::cout<<"Sequence containers are:";
    for(int i=0;i<sequence_container.size();i++){
        std::cout<<sequence_container[i]<<",";
    }
    std::cout<<std::endl;

和数组一样，array通过[]运算符来访问。

下面，我们让迭代器出场，看看用迭代器的方式如何遍历array:

    std::cout<<"2.Sequence containers are:";
    for(auto pos = sequence_container.begin();pos!=sequence_container.end();++pos){
        std::cout<<*pos<<",";
    }
    std::cout<<std::endl;

第一个元素是array.begin()，最后一个元素是array.end()，取下一个元素用++运算符。C++11的auto又在这时刻发挥了作用，有了它，我们根本不需要知道迭代器的存在。管它是什么呢，反正++可以取下一个，*可以获取当前的值。一般情况下已经足够用了。

下面，C++11又为我们送上一份小礼物，简便写法。大家直接看例程吧：

    std::cout<<"3.Sequence containers are:";
    for(auto elem : sequence_container){
        std::cout<<elem<<",";
    }
    std::cout<<std::endl;

没错，连begin()和end()这样的迭代函数和++,*这样的运算符都给封装起来了，我们拿到手的时候，已经是一个元素，在本例中就是个字符串。

我们再将算法应用到array容器，给容器做个排序：

    sort(sequence_container.begin(),sequence_container.end());
    std::cout<<"4.After sorting,Sequence containers are:";
    for(auto elem : sequence_container){
        std::cout<<elem<<",";
    }
    std::cout<<std::endl;

输出之后的结果就是对结果进行排序之后的了,如下：

3.Sequence containers are:array,vector,deque,list,forward_list,
4.After sorting,Sequence containers are:array,deque,forward_list,list,vector,

向后增长的动态数组：vector

忍受了固定大小的array之后，我们请向后扩展的数组vector粉墨登场。

vector的特点就是，在后面添加元素，也就是push_back函数的性能好。但是在前面和中间的性能就要引起其后的元素向后移动。

我们来个push_back的例子：

    std::vector<std::string> vector_seq_container;
    vector_seq_container.push_back("array");
    vector_seq_container.push_back("vector");
    vector_seq_container.push_back("deque");
    vector_seq_container.push_back("list");
    vector_seq_container.push_back("forward_list");

迭代器和算法的用法和array一模一样：

    std::cout<<"5.Sequence containers are:";
    for(auto elem : vector_seq_container){
        std::cout<<elem<<",";
    }
    std::cout<<std::endl;
    
    sort(vector_seq_container.begin(),vector_seq_container.end());
    std::cout<<"6.After sorting,Sequence containers are:";
    for(auto elem : vector_seq_container){
        std::cout<<elem<<",";
    }
    std::cout<<std::endl;

双端队列：deque

deque是既可以在后面push_back，也可以在前面加元素push_front.

    std::deque<std::string> deque_seq_container;
    deque_seq_container.push_front("array");
    deque_seq_container.push_back("vector");
    deque_seq_container.push_front("deque");
    deque_seq_container.push_back("list");
    deque_seq_container.push_front("forward_list");

迭代和算法使用，还是跟array和vector都一样。

双向链表list

list的能力更强了，不但支持push_back和push_front，还支持中间插入insert，可以在迭代器的某个位置之前插入元素。

单向链表forward list

单向链表forward list的能力在list的基础上反而是受到了限制，只能向前，不能向后。所以在forward list中是没有push_back函数的。

集合 set 和 unordered_set

set通常使用红黑树来实现。
有序结构不是存储顺序的结构，所以push_back之类的就没有意义了，只要有个insert就可以了。
而unordered_set通常采用哈希表来实现。
但是集合元素值一旦放进去，就不能直接修改了，否则排序就会乱掉。

我们来看个例子：

    std::set<std::string> sorted_container;
    sorted_container.insert("set");
    sorted_container.insert("multiset");
    sorted_container.insert("map");
    sorted_container.insert("multimap");
    for(auto elem : sorted_container){
        std::cout<<elem<<",";
    }
    std::cout<<std::endl;
    
    std::unordered_set<std::string> unordered_container;
    unordered_container.insert("set");
    unordered_container.insert("multiset");
    unordered_container.insert("map");
    unordered_container.insert("multimap");
    for(auto elem : unordered_container){
        std::cout<<elem<<",";
    }
    std::cout<<std::endl;

输出是这样的：

map,multimap,multiset,set,
multimap,multiset,map,set,

从上面的输出可以看到，set是严格按字母顺序排序的。而unordered_set就没有这么讲究了，map还排在multiset之后。

可重复集合 multiset和unordered_multiset

元素可以重复，其余跟集合基本一致。

排序树 map 和哈希表 unordered_map

其实跟集合差不多，就是把元素换成std::pair了而己。

我们来看例子：

    std::map<int,std::string> map_container;
    map_container.insert(std::make_pair(4,"set"));
    map_container.insert(std::make_pair(1,"multiset"));
    map_container.insert(std::make_pair(2,"map"));
    map_container.insert(std::make_pair(3,"multimap"));
    for(auto elem : map_container){
        std::cout<<elem.first<<":"<<elem.second<<",";
    }
    std::cout<<std::endl;

    std::unordered_map<int,std::string> umap_container;
    umap_container.insert(std::make_pair(4,"set"));
    umap_container.insert(std::make_pair(1,"multiset"));
    umap_container.insert(std::make_pair(2,"map"));
    umap_container.insert(std::make_pair(3,"multimap"));
    for(auto elem : umap_container){
        std::cout<<elem.first<<":"<<elem.second<<",";
    }
    std::cout<<std::endl;

输出如下：

1:multiset,2:map,3:multimap,4:set,
3:multimap,2:map,1:multiset,4:set,

map是严格按key值排序的，而unordered_map这个哈希表当然就没有这么严格了。

排序可重复键的树 multimap

值重复的排序树和哈希表，就不多说了。

小结

我们用这么少的篇幅，其实已经把STL的主要容器都给大家介始完了。同时，大家也体会到了迭代器和算法的作用。所以大家应该有信心，我们是可以学完整个C++标准库的。

常用容器：

1. vector：变长数组，用push_back增加新元素。
2. list：双向链表，可以使用push_back,push_front和insert
3. unordered_set：集合，insert元素
4. unordered_map：哈希表，insert std::pair

经常要用到排序的，就用set或者map。
有两端操作需求的，可以用deque，它支持push_back和push_front，但是不支持insert。
要求元素重复的，记得set和map都有重复元素版本。

C++11提供了改进的for循环，可以很好地包装迭代器。

算法是操作容器的通用工具。

最后小小补充一下算法的思想，它是跟面向对象设计的思想是完全相反的。OOP的思想是将对象的属性和函数封装在一起，形成对象。但是算法的思想是与容器对象无关，将通用的操作抽象出来。

好了，这讲就这么多。