C++ Standard Template Library STL(undone)

目录

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

1. C++标准模版库(STL)

STL就是Standard Template Library，标准模板库。从根本上说

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

STL的目的是标准化组件，这样我们就不用重新开发它们了。你可以仅仅使用这些现成的组件。STL现在是C++的一部分，因此不用额外安装什麽。它被内建在你的编译器之内
0X1: STL容器的特点

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

概括地说，STL所有的东西由容器、算法、和允许算法工作在容器中的元素上的iterator这3部分组成。算法以合适、标准的方法操作对象，并可通过iterator得到容器精确的长度。一旦做了这些，它们就在也不会"跑出边界"。还有一些其他的对这些核心组件类型有功能性增强的组件，例如函数对象。我们将会逐一学习

Relevant Link:

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

2. C++ STL容器

0x1: 容器简介

在面向对象程序中，大多引入了容器的概念。容器实质上是一组相同类型对象的集合，但它不仅仅是数组那么简单，它实现了比数组更复杂的数据结构，能够实现更复杂的功能。C++标准模版库里提供了10种通用的容器，它基本可以解决程序中遇到的大部分问题

容器另一个好处就是可以自行扩展，解决问题是我们不知道需要存储多少个对象，数组在这方面是个欠缺。容器可以为你申请内存、释放内存，并且使用最优的算法来执行你的命令，简单来说，使用STL容器不需要考虑申请空间浪费、或者空间不够的上溢出问题

0x2: 容器的分类

. 顺序性容器
各元素之间有顺序关系的线性表，是一种线性关系的有序集群，顺序容器中的元素均有固定的位置，除非用删除和插入来改变它的位置，这个位置和元素本身无关，和操作时间和地点有关
    ) vector: 从后面快速的插入与删除，直接访问任何元素
    ) deque: 从前面或后面快速的插入与删除，直接访问任何元素
    ) list: 双联表，从任何位置插入和删除，不能直接访问任意元素

. 关联式容器
非线性的树结构(二叉树结构)，各元素之间没有严格的物理顺序。关联容器提供了根据元素特点排序的功能，迭代器根据元素特点"顺序"(这里的顺序是一个数学概念上的顺序，指满足一定的"关系")的取元素
    ) set: 快速查找，不允许重复值
    ) multiset: 快速查找，允许重复值
    ) map: 一对多映射，基于关键字快速查找，不允许重复值
    ) multimap: 一对多映射，基于关键字快速查找，允许重复值

. 容器适配器
让一种已存在的容器类型采用另一种不同抽象类型的工作方式来实现的一种机制。实质上仅发生了接口转换
    ) stack: 后进先出
    ) queue: 先进先出
    ) priority_queue: 最高优先级第一个出列

Relevant Link:

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

3. C++ STL 顺序性容器

0x1: vector

我们可以把它看成动态数组，创建一个vector后，它会在内存中分配一块连续的区域存储数据，初始空间可以指定也可以由vector决定(capacity()函数返回值)
当数据存储空间超过分配空间，vector会重新分配一块内存区域，这样的分配很耗时，动作如下

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

所以，如果vector保存的数据量很大，这样的操作会导致很糟糕的性能(频繁地申请和释放内存是一个很费时的操作)。只有在预知空间大小的情况下，vector的性能才是最好的

Example(从末尾位置顺序存取)

// vector::begin/end
#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector;
  for (int i=; i<=; 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 ;
}

Example(任意位置随机存取)

// vector::at
#include <iostream>
#include <vector>

int main ()
{
  std::vector<int> myvector ();   // 10 zero-initialized ints

  // assign some values:
  for (unsigned i=; i<myvector.size(); i++)
    myvector.at(i)=i;

  std::cout << "myvector contains:";
  for (unsigned i=; i<myvector.size(); i++)
    std::cout << ' ' << myvector.at(i);
  std::cout << '\n';

  return ;
}

Relevant Link:

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

0x2: List

双向链表List结构，指针将所有元素链接起来。根据其结构特点(寻址慢是链表的特点)，List检索性能不好，需要顺序查找，检索时间与目标元素位置成正比。但是它可以对快速的删除和插入(链表的插入和删除不需要移动其他的元素)

Example(两头位置顺序存取)

// list::pop_back
#include <iostream>
#include <list>

int main ()
{
    std::list<int> mylist;
    int sum ();
    //从头部顺序存储
    mylist.push_front();
    mylist.push_front();
    mylist.push_front();
    mylist.push_front();
    mylist.push_front();

    mylist.push_back();
    mylist.push_back();
    mylist.push_back();
    mylist.push_back();

    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();
    mylist.push_front();
    mylist.push_front();
    mylist.push_front();
    mylist.push_front();

    mylist.push_back();
    mylist.push_back();
    mylist.push_back();
    mylist.push_back();

    while (!mylist.empty())
    {
        sum = mylist.back();
        mylist.pop_back();
        std::cout << "The elements of current item is: " << sum << '\n';
    }

    return ;
}

Example(任意位置顺序插入)

// 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=; i<=; ++i)
    {
        mylist.push_back(i); // 1 2 3 4 5
    }
    it = mylist.begin();
    ++it;       // it points now to number 2           ^

    mylist.insert (it,);                        // 1 10 2 3 4 5

    // "it" still points to number 2                      ^
    mylist.insert (it,,);                      // 1 10 20 20 2 3 4 5

    --it;       // it points now to the second 20            ^

    std::vector<int> myvector (,);
    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 ;
}

Relevant Link:

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

0x3: deque

双端队列deque是一种可以对序列两端插入和删除的容器，可以快速的随即查找。它不像vector把所有元素存储在同一内存块，而是采用多个连续的存储块，并且一个映射结构中保存对这些块和元素顺序的跟踪。deque是vector和List优缺点的结合，它是处于两者之间的一种容器。支持[]及vector.at()，性能没有vector好

Example(从两头位置顺序存取)

// list::pop_back
#include <iostream>
#include <deque>

int main ()
{
    std::deque<int> mydeque;
    int sum ();
    //从头部顺序存储
    mydeque.push_front();
    mydeque.push_front();
    mydeque.push_front();
    mydeque.push_front();
    mydeque.push_front();

    mydeque.push_back();
    mydeque.push_back();
    mydeque.push_back();
    mydeque.push_back();

    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();
    mydeque.push_front();
    mydeque.push_front();
    mydeque.push_front();
    mydeque.push_front();

    mydeque.push_back();
    mydeque.push_back();
    mydeque.push_back();
    mydeque.push_back();

    while (!mydeque.empty())
    {
        sum = mydeque.back();
        mydeque.pop_back();
        std::cout << "The elements of current item is: " << sum << '\n';
    }

    return ;
}

Example(任意位置随机存取)

// deque::at
#include <iostream>
#include <deque>

int main ()
{
    std::deque<unsigned> mydeque ();   // 10 zero-initialized unsigneds

    // assign some values:
    for (unsigned i=; i<mydeque.size(); i++)
    {
        mydeque.at(i)=i;
    }
    std::cout << "mydeque contains:";
    for (unsigned i=; i<mydeque.size(); i++)
    {
        std::cout << ' ' << mydeque.at(i);
    }
    std::cout << '\n';
    return ;
}

Relevant Link:

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

0x4: vector、deque、list的优缺点比较

aaarticlea/png;base64,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" alt="" />

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

这是一种数据结构的平衡选择

4. C++ STL 关联式容器

0x1: set

set又称集合，实际上就是一组元素的集合，但其中所包含的元素的值是唯一的，且是按一定顺序排列的，集合中的每个元素被称作集合中的实例。因为其内部是通过链表的方式来组织，所以在插入的时候比vector快，但在查找和末尾添加上被vector慢

Example(自动排序)

// set::begin/end
#include <iostream>
#include <set>

int main ()
{
    int myints[] = {,,,,};
    std::set<int> myset (myints,myints+);

    std::cout << "myset contains:";
    for (std::set<int>::iterator it=myset.begin(); it!=myset.end(); ++it)
    {
        std::cout << ' ' << *it;
    }
    std::cout << '\n';

    return ;
}

Example(不允许重复值)

// 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=; i<=; ++i)
    {
        myset.insert(i*);    // set: 10 20 30 40 50
    }
    ret = myset.insert();               // no new element inserted

    if (ret.second==false)
    {
        it=ret.first;  // "it" now points to element 20
    }

    myset.insert (it,);                 // max efficiency inserting
    myset.insert (it,);                 // max efficiency inserting
    myset.insert (it,);                 // no max efficiency inserting

    int myints[]= {,,};              // 10 already in set, not inserted
    myset.insert (myints,myints+);

    std::cout << "myset contains:";
    for (it=myset.begin(); it!=myset.end(); ++it)
    {
        std::cout << ' ' << *it;
    }
    std::cout << '\n';

    return ;
}

Relevant Link:

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

0x2: multiset

multiset是多重集合，其实现方式和set是相似的，只是它不要求集合中的元素是唯一的，也就是说集合中的同一个元素可以出现多次

0x3: map

map提供一种"键-值"关系的一对一的数据存储能力。其"键"在容器中不可重复，且按一定顺序排列
(其实我们可以将set也看成是一种键-值关系的存储，只是它只有键没有值。它是map的一种特殊形式)
由于map其是按链表的方式存储，它也继承了链表的优缺点

Example(按键值进行排序)

// map::begin/end
#include <iostream>
#include <map>

int main ()
{
    std::map<char,int> mymap;
    std::map<char,int>::iterator it;

    mymap['b'] = ;
    mymap['a'] = ;
    mymap['c'] = ;

    // show content:
    for (std::map<char,int>::iterator it=mymap.begin(); it!=mymap.end(); ++it)
    {
        std::cout << it->first << " => " << it->second << '\n';
    }
    return ;
}

Example(自定义排序函数1)

/*
优先按照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) > ;
    }
};

typedef multiset<Word, MapCmp> Mapwords;
Mapwords words;

int main()
{
    words.insert(Word("a",));
    words.insert(Word("b",));
    words.insert(Word("c",));
    words.insert(Word("d",));
    words.insert(Word("e",));
    words.insert(Word("f",-));

    Mapwords::iterator mbegin;
    Mapwords::iterator mend = words.end();
    for( mbegin = words.begin(); mbegin != mend; ++mbegin)
    {
        cout << mbegin->str << '\t' << mbegin->prob << endl;
    }

    return ;
}

Example(自定义排序函数2)

Relevant Link:

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

0x4: multimap

multimap和map的原理基本相似，它允许"键"在容器中可以不唯一

5. C++ STL 容器适配器

适配器是容器的接口，它本身不能直接保存元素，它保存元素的机制是调用另一种顺序容器去实现，即可以把适配器看作"它保存一个容器，这个容器再保存所有元素"。适配器起到一个转换接口的作用。STL中提供的三种适配器可以由某一种顺序容器去实现

//默认情况
. stack基于deque器实现
栈stack的特点是后进先出，所以它关联的基本容器可以是任意一种顺序容器，因为这些容器类型结构都可以提供栈的操作要求，它们都提供了push_back 、pop_back 和back 操作

. queue基于deque器实现
队列queue的特点是先进先出，适配器要求其关联的基础容器必须提供pop_front作，因此其不能建立在vector容器上

. priority_queue基于vector容器实现
优先级队列priority_queue适配器要求提供随机访问功能，因此不能建立在list容器上

当然在创建一个适配器时也可以指定具体的实现容器，创建适配器时在第二个参数上指定具体的顺序容器可以覆盖适配器的默认实现

0x1: stack

Example(Last in First out,LIFO)

// stack::push/pop
#include <iostream>       // std::cout
#include <stack>          // std::stack

int main ()
{
    std::stack<int> mystack;

    for (int i=; i<; ++i)
    {
        mystack.push(i);
    }

    std::cout << "Popping out elements...";
    while (!mystack.empty())
    {
        std::cout << ' ' << mystack.top();
        mystack.pop();
    }
    std::cout << '\n';

    return ;
}

Relevant Link:

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

0x2: queue

Example(First In First Out、FIFO)

// queue::push/pop
#include <iostream>       // std::cin, std::cout
#include <queue>          // std::queue

int main ()
{
    std::queue<int> myqueue;
    int myint;

    std::cout << "Please enter some integers (enter 0 to end):\n";

    for (int i=; i<; ++i)
    {
        myqueue.push(i);
    }

    std::cout << "myqueue contains: ";
    while (!myqueue.empty())
    {
        std::cout << ' ' << myqueue.front();
        myqueue.pop();
    }
    std::cout << '\n';

    return ;
}

Relevant Link:

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

0x3: priority_queue

priority_queue 优先级队列是一个拥有权值概念的单向队列queue，在这个队列中，所有元素是按优先级排列的(也可以认为queue是个按进入队列的先后做为优先级的优先级队列——先进入队列的元素优先权要高于后进入队列的元素)

Example

// priority_queue::push/pop
#include <iostream>       // std::cout
#include <queue>          // std::priority_queue

int main ()
{
    std::priority_queue<int> mypq;

    mypq.push();
    mypq.push();
    mypq.push();
    mypq.push();

    std::cout << "Popping out elements...";
    while (!mypq.empty())
    {
        std::cout << ' ' << mypq.top();
        mypq.pop();
    }
    std::cout << '\n';

    return ;
}

Relevant Link:

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

在继续学习STL算法之前，我们对STL容器的特性和优缺点进行一个梳理总结

aaarticlea/png;base64,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" alt="" />

在理解了STL各个容器的底层实现数据结构的基础上，我们就可以理解针对这些容器的对应存储方式，之所以有的是单头操作，有的是双头操作，有的可以随意存取，有的任意位置插入，本质上都和它们的数据结构有关

3. C++ STL算法

undone

Relevant Link:

http://www.cnblogs.com/nanke/archive/2011/05/10/2042662.html

4. C++ STL边界限制

undone

Copyright (c) 2014 LittleHann All rights reserved