1. C++标准模版库(Standard Template Library STL)2. C++ STL容器3. C++ STL 顺序性容器4. C++ STL 关联式容器5. C++ STL 容器适配器6. C++ STL算法7. C++ STL边界限制

1. STL是一些"容器"集合2. STL也是算法和其他一些组件的集合3. 这里的"容器"和"算法"的集合指的是世界上很多聪明人很多年的杰作，使用C++的STL模版库，我们可以像使用C#那样简单的进行面向对象的编程

1. STL容器可以保存    1) 对象    2) 内建对象    3) 类对象2. STL会安全的保存对象3. STL定义了我们能够操作的这个对象的接口4. STL算法是标准算法，我们可以把它们应用在那些容器中的对象上。这些算法都有很著名的执行特性。它们可以    1) 给对象排序，    2) 删除对象    3) 给对象记数    4) 比较对象    5) 找出特殊的对象    6) 把对象合并到另一个容器中    7) ...5. STL iteratorSTL iterator就像是容器中指向对象的指针。STL的算法使用iterator在容器上进行操作6. Iterator设置算法的边界、容器的长度、和其他一些事情    1) 有些iterator仅让算法读元素    2) 有一些让算法写元素    3) 有一些则两者都行7. Iterator也决定在容器中处理的方向     1) 通过调用容器的成员函数begin()来得到一个指向一个容器起始位置的iterator    2) 调用一个容器的 end() 函数来得到过去的最后一个值 

http://docs.huihoo.com/gnu/linux/stl.htmlhttp://segmentfault.com/blog/simbest/1190000000325549

1. 顺序性容器各元素之间有顺序关系的线性表，是一种线性关系的有序集群，顺序容器中的元素均有固定的位置，除非用删除和插入来改变它的位置，这个位置和元素本身无关，和操作时间和地点有关    1) vector: 从后面快速的插入与删除，直接访问任何元素    2) deque: 从前面或后面快速的插入与删除，直接访问任何元素    3) list: 双联表，从任何位置插入和删除，不能直接访问任意元素2. 关联式容器非线性的树结构(二叉树结构)，各元素之间没有严格的物理顺序。关联容器提供了根据元素特点排序的功能，迭代器根据元素特点"顺序"(这里的顺序是一个数学概念上的顺序，指满足一定的"关系")的取元素    1) set: 快速查找，不允许重复值    2) multiset: 快速查找，允许重复值    3) map: 一对多映射，基于关键字快速查找，不允许重复值    4) multimap: 一对多映射，基于关键字快速查找，允许重复值3. 容器适配器让一种已存在的容器类型采用另一种不同抽象类型的工作方式来实现的一种机制。实质上仅发生了接口转换    1) stack: 后进先出    2) queue: 先进先出    3) priority_queue: 最高优先级第一个出列

http://blog.csdn.net/guoshenglong11/article/details/9469881

1. vector申请一块更大内存区域 2. 将原来的数据拷贝到新的内存区域 3. 销毁原来内存块数据4. 释放原来内存空间

// vector::begin/end#include <iostream>#include <vector>int main (){  std::vector<int> myvector;  for (int i=1; i<=5; i++)  {      myvector.push_back(i);  }  std::cout << "myvector contains:";  for (std::vector<int>::iterator it = myvector.begin() ; it != myvector.end(); ++it)  {      std::cout << ‘ ‘ << *it;  }  std::cout << ‘\n‘;  return 0;}

// vector::at#include <iostream>#include <vector>int main (){  std::vector<int> myvector (10);   // 10 zero-initialized ints  // assign some values:  for (unsigned i=0; i<myvector.size(); i++)    myvector.at(i)=i;  std::cout << "myvector contains:";  for (unsigned i=0; i<myvector.size(); i++)    std::cout << ‘ ‘ << myvector.at(i);  std::cout << ‘\n‘;  return 0;}

http://www.cplusplus.com/reference/vector/vector/http://www.cplusplus.com/reference/vector/vector/begin/http://www.cplusplus.com/reference/vector/vector/at/

// list::pop_back#include <iostream>#include <list>int main (){    std::list<int> mylist;    int sum (0);    //从头部顺序存储    mylist.push_front(500);    mylist.push_front(400);    mylist.push_front(300);    mylist.push_front(200);    mylist.push_front(100);    mylist.push_back(600);    mylist.push_back(700);    mylist.push_back(800);    mylist.push_back(900);    while (!mylist.empty())    {        sum = mylist.front();        mylist.pop_front();        std::cout << "The elements of current item is: " << sum << ‘\n‘;    }    std::cout << "-----------------------" << ‘\n‘;    //从尾部顺序存储    mylist.push_front(500);    mylist.push_front(400);    mylist.push_front(300);    mylist.push_front(200);    mylist.push_front(100);    mylist.push_back(600);    mylist.push_back(700);    mylist.push_back(800);    mylist.push_back(900);    while (!mylist.empty())    {        sum = mylist.back();        mylist.pop_back();        std::cout << "The elements of current item is: " << sum << ‘\n‘;    }    return 0;}

// inserting into a list#include <iostream>#include <list>#include <vector>int main (){    std::list<int> mylist;    std::list<int>::iterator it;    // set some initial values:    for (int i=1; i<=5; ++i)    {        mylist.push_back(i); // 1 2 3 4 5    }    it = mylist.begin();    ++it;       // it points now to number 2           ^    mylist.insert (it,10);                        // 1 10 2 3 4 5    // "it" still points to number 2                      ^    mylist.insert (it,2,20);                      // 1 10 20 20 2 3 4 5    --it;       // it points now to the second 20            ^    std::vector<int> myvector (2,30);    mylist.insert (it,myvector.begin(),myvector.end());                                        // 1 10 20 30 30 20 2 3 4 5                                        //               ^    std::cout << "mylist contains:";    for (it=mylist.begin(); it!=mylist.end(); ++it)    {        std::cout << ‘ ‘ << *it;    }    std::cout << ‘\n‘;    return 0;}

http://docs.huihoo.com/gnu/linux/stl.htmlhttp://www.cplusplus.com/reference/list/list/insert/

// list::pop_back#include <iostream>#include <deque>int main (){    std::deque<int> mydeque;    int sum (0);    //从头部顺序存储    mydeque.push_front(500);    mydeque.push_front(400);    mydeque.push_front(300);    mydeque.push_front(200);    mydeque.push_front(100);    mydeque.push_back(600);    mydeque.push_back(700);    mydeque.push_back(800);    mydeque.push_back(900);    while (!mydeque.empty())    {        sum = mydeque.front();        mydeque.pop_front();        std::cout << "The elements of current item is: " << sum << ‘\n‘;    }    std::cout << "-----------------------" << ‘\n‘;    //从尾部顺序存储    mydeque.push_front(500);    mydeque.push_front(400);    mydeque.push_front(300);    mydeque.push_front(200);    mydeque.push_front(100);    mydeque.push_back(600);    mydeque.push_back(700);    mydeque.push_back(800);    mydeque.push_back(900);    while (!mydeque.empty())    {        sum = mydeque.back();        mydeque.pop_back();        std::cout << "The elements of current item is: " << sum << ‘\n‘;    }    return 0;}

// deque::at#include <iostream>#include <deque>int main (){    std::deque<unsigned> mydeque (10);   // 10 zero-initialized unsigneds    // assign some values:    for (unsigned i=0; i<mydeque.size(); i++)    {        mydeque.at(i)=i;    }    std::cout << "mydeque contains:";    for (unsigned i=0; i<mydeque.size(); i++)    {        std::cout << ‘ ‘ << mydeque.at(i);    }    std::cout << ‘\n‘;    return 0;}

http://www.cplusplus.com/reference/deque/deque/at/http://www.cplusplus.com/reference/deque/deque/?kw=deque

1. vector是一段连续的内存块，而deque是多个连续的内存块，list是所有数据元素分开保存，可以是任何两个元素没有连续2. vector的查询性能最好，并且在末端增加数据也很好，除非它重新申请内存段；适合高效地随机存储。3. list是一个链表，任何一个元素都可以是不连续的，但它都有两个指向上一元素和下一元素的指针。所以它对插入、删除元素性能是最好的，而查询性能非常差；适合大量地插入和删除操作而不关心随机存取的需求4. deque是介于两者之间，它兼顾了数组和链表的优点，它是分块的链表和多个数组的联合。所以它有被list 好的查询性能，有被vector好的插入、删除性能。 如果你需要随即存取又关心两端数据的插入和删除，那么deque是最佳之
选 

// set::begin/end#include <iostream>#include <set>int main (){    int myints[] = {75,23,65,42,13};    std::set<int> myset (myints,myints+5);    std::cout << "myset contains:";    for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)    {        std::cout << ‘ ‘ << *it;    }    std::cout << ‘\n‘;    return 0;}

// set::insert (C++98)#include <iostream>#include <set>int main (){    std::set<int> myset;    std::set<int>::iterator it;    std::pair<std::set<int>::iterator,bool> ret;    // set some initial values:    for (int i=1; i<=5; ++i)    {        myset.insert(i*10);    // set: 10 20 30 40 50    }    ret = myset.insert(20);               // no new element inserted    if (ret.second==false)    {        it=ret.first;  // "it" now points to element 20    }    myset.insert (it,25);                 // max efficiency inserting    myset.insert (it,24);                 // max efficiency inserting    myset.insert (it,26);                 // no max efficiency inserting    int myints[]= {5,10,15};              // 10 already in set, not inserted    myset.insert (myints,myints+3);    std::cout << "myset contains:";    for (it=myset.begin(); it!=myset.end(); ++it)    {        std::cout << ‘ ‘ << *it;    }    std::cout << ‘\n‘;    return 0;}

http://www.cplusplus.com/reference/set/set/?kw=sethttp://www.cplusplus.com/reference/set/set/begin/http://www.cplusplus.com/reference/set/set/insert/

// map::begin/end#include <iostream>#include <map>int main (){    std::map<char,int> mymap;    std::map<char,int>::iterator it;    mymap[‘b‘] = 100;    mymap[‘a‘] = 200;    mymap[‘c‘] = 300;    // show content:    for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)    {        std::cout << it->first << " => " << it->second << ‘\n‘;    }    return 0;}

/*优先按照prob进行降序排序如果prob相等，则按照str的字符顺序进行降序排序*/#include <iostream>#include <set>#include <string>using namespace std;struct Word{    string str;    int    prob;    Word(string s, int i):str(s),prob(i){};    Word(){};};struct MapCmp{    bool operator()(const Word s1, const Word s2) const    {        if( s1.prob != s2.prob )        {            return s1.prob > s2.prob;        }        return s1.str.compare(s2.str) > 0;    }};typedef multiset<Word, MapCmp> Mapwords;Mapwords words;int main(){    words.insert(Word("a",1));    words.insert(Word("b",1));    words.insert(Word("c",2));    words.insert(Word("d",3));    words.insert(Word("e",3));    words.insert(Word("f",-2));    Mapwords::iterator mbegin;    Mapwords::iterator mend = words.end();    for( mbegin = words.begin(); mbegin != mend; ++mbegin)    {        cout << mbegin->str << ‘\t‘ << mbegin->prob << endl;    }    return 0;}

http://www.cplusplus.com/reference/map/map/begin/http://blog.sina.com.cn/s/blog_5674da3201009mq2.html

//默认情况1. stack基于deque器实现栈stack的特点是后进先出，所以它关联的基本容器可以是任意一种顺序容器，因为这些容器类型结构都可以提供栈的操作要求，它们都提供了push_back 、pop_back 和back 操作2. queue基于deque器实现队列queue的特点是先进先出，适配器要求其关联的基础容器必须提供pop_front作，因此其不能建立在vector容器上3. priority_queue基于vector容器实现优先级队列priority_queue适配器要求提供随机访问功能，因此不能建立在list容器上

// stack::push/pop#include <iostream>       // std::cout#include <stack>          // std::stackint main (){    std::stack<int> mystack;    for (int i=0; i<5; ++i)    {        mystack.push(i);    }    std::cout << "Popping out elements...";    while (!mystack.empty())    {        std::cout << ‘ ‘ << mystack.top();        mystack.pop();    }    std::cout << ‘\n‘;    return 0;}

http://www.cplusplus.com/reference/stack/stack/?kw=stackhttp://www.cplusplus.com/reference/stack/stack/push/

// queue::push/pop#include <iostream>       // std::cin, std::cout#include <queue>          // std::queueint main (){    std::queue<int> myqueue;    int myint;    std::cout << "Please enter some integers (enter 0 to end):\n";    for (int i=0; i<5; ++i)    {        myqueue.push(i);    }    std::cout << "myqueue contains: ";    while (!myqueue.empty())    {        std::cout << ‘ ‘ << myqueue.front();        myqueue.pop();    }    std::cout << ‘\n‘;    return 0;}

http://www.cplusplus.com/reference/queue/queue/?kw=queuehttp://www.cplusplus.com/reference/queue/queue/push/

// priority_queue::push/pop#include <iostream>       // std::cout#include <queue>          // std::priority_queueint main (){    std::priority_queue<int> mypq;    mypq.push(30);    mypq.push(100);    mypq.push(25);    mypq.push(40);    std::cout << "Popping out elements...";    while (!mypq.empty())    {        std::cout << ‘ ‘ << mypq.top();        mypq.pop();    }    std::cout << ‘\n‘;    return 0;}

http://www.cplusplus.com/reference/queue/priority_queue/?kw=priority_queuehttp://www.cplusplus.com/reference/queue/priority_queue/push/