C++ STL总结

转载自：http://www.cnblogs.com/shiyangxt/archive/2008/09/11/1289493.html
先MARK为敬

学无止境！！！

第一部分：（参考百度百科）

 1、STL简介

STL（Standard Template Library，标准模板库)是惠普实验室开发的一系列软件的统称。它是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室工做时所开发出来

的。如今虽然说它主要出如今C++中，但在被引入C++以前该技术就已经存在了很长的一段时间。

 

STL的代码从广义上讲分为三类：algorithm（算法）、container（容器）和iterator（迭代器），几乎全部的代码都采用了模板类和模版函数的方式，这相比于传统的由函数和类

 

组成的库来讲提供了更好的代码重用机会。在C++标准中，STL被组织为下面的13个头文件：<algorithm>、<deque>、<functional>、<iterator>、<vector>、<list>、<map>、

<memory>、<numeric>、<queue>、<set>、<stack>和<utility>。 

2、算法

你们都能取得的一个共识是函数库对数据类型的选择对其可重用性起着相当重要的做用。举例来讲，一个求方根的函数，在使用浮点数做为其参数类型的状况下的可重用性确定比

使用整型做为它的参数类性要高。而C++经过模板的机制容许推迟对某些类型的选择，直到真正想使用模板或者说对模板进行特化的时候，STL就利用了这一点提供了至关多的有用

算法。它是在一个有效的框架中完成这些算法的——你能够将全部的类型划分为少数的几类，而后就能够在模版的参数中使用一种类型替换掉同一种类中的其余类型。

STL提供了大约100个实现算法的模版函数，好比算法for_each将为指定序列中的每个元素调用指定的函数，stable_sort以你所指定的规则对序列进行稳定性排序等等。这样一来

，只要咱们熟悉了STL以后，许多代码能够被大大的化简，只须要经过调用一两个算法模板，就能够完成所须要的功能并大大地提高效率。

 

算法部分主要由头文件<algorithm>，<numeric>和<functional>组成。

<algorithm>是全部STL头文件中最大的一个（尽管它很好理解），它是由一大堆模版函数组成的，能够认为每一个函数在很大程度上都是独立的，其中经常使用到的功能范围涉及到比较、交换、查找、遍历操做、复制、修改、移除、反转、排序、合并等等。

 

<numeric>体积很小，只包括几个在序列上面进行简单数学运算的模板函数，包括加法和乘法在序列上的一些操做。

 

<functional>中则定义了一些模板类，用以声明函数对象。

 

3、容器

在实际的开发过程当中，数据结构自己的重要性不会逊于操做于数据结构的算法的重要性，当程序中存在着对时间要求很高的部分时，数据结构的选择就显得更加剧要。

经典的数据结构数量有限，可是咱们经常重复着一些为了实现向量、链表等结构而编写的代码，这些代码都十分类似，只是为了适应不一样数据的变化而在细节上有所出入。STL容器

就为咱们提供了这样的方便，它容许咱们重复利用已有的实现构造本身的特定类型下的数据结构，经过设置一些模版类，STL容器对最经常使用的数据结构提供了支持，这些模板的参数

容许咱们指定容器中元素的数据类型，能够将咱们许多重复而乏味的工做简化。

 

容器部分主要由头文件<vector>,<list>,<deque>,<set>,<map>,<stack>和<queue>组成。对于经常使用的一些容器和容器适配器（能够看做由其它容器实现的容器），能够经过下表总结一下它们和相应头文件的对应关系。

 

向量(vector) 连续存储的元素<vector>

列表(list)       由节点组成的双向链表，每一个结点包含着一个元素<list>

双队列(deque) 连续存储的指向不一样元素的指针所组成的数组<deque>

集合(set) 由节点组成的红黑树，每一个节点都包含着一个元素，节点之间以某种做用于元素对的谓词排列，没有两个不一样的元素可以拥有相同的次序 <set>

多重集合(multiset) 容许存在两个次序相等的元素的集合 <set>

栈(stack) 后进先出的值的排列 <stack>

队列(queue) 先进先出的执的排列 <queue>

优先队列(priority_queue) 元素的次序是由做用于所存储的值对上的某种谓词决定的的一种队列 <queue>

映射(map) 由{键，值}对组成的集合，以某种做用于键对上的谓词排列 <map>

多重映射(multimap) 容许键对有相等的次序的映射 <map>

 

4、迭代器

 

下面要说的迭代器从做用上来讲是最基本的部分，但是理解起来比前二者都要费力一些（至少笔者是这样）。软件设计有一个基本原则，全部的问题均可以经过引进一个间接层来

简化，这种简化在STL中就是用迭代器来完成的

。

归纳来讲，迭代器在STL中用来将算法和容器联系起来，起着一种黏和剂的做用。几乎STL提供的全部算法都是经过迭代器存取元素序列进行工做的，每个容器都定义了其自己所专有的迭代器，用以存取容器中的元素。

 

迭代器部分主要由头文件<utility>,<iterator>和<memory>组成。

<utility>是一个很小的头文件，它包括了贯穿使用在STL中的几个模板的声明，

<iterator>中提供了迭代器使用的许多方法，而对于<memory>的描述则十分的困难，它以不一样寻常的方式为容器中的元素分配存储空间，同时也为某些算法执行期间产生的临时对象提供机制,<memory>中的主要部分是模板类allocator，它负责产生全部容器中的默认分配器。

   对于以前不太了解STL的读者来讲，上面的文字只是十分归纳地描述了一下STL的框架，对您理解STL的机制乃至使用STL所起到的帮助微乎甚微，这不光是由于深刻STL须要对C++的高级应用有比较全面的了解，更由于STL的三个部分算法、容器和迭代器三部分是互相牵制或者说是紧密结合的。从概念上讲最基础的部分是迭代器，但是直接学习迭代器会遇到许多抽象枯燥和繁琐的细节，然而不真正理解迭代器又是没法直接进入另两部分的学习的（至少对剖析源码来讲是这样）。能够说，适应STL处理问题的方法是须要花费必定的时间的，可是以此为代价，STL取得了一种十分难得的独立性，它经过迭代器能在尽量少地知道某种数据结构的状况下完成对这一结构的运算，因此下决心钻研STL的朋友们千万不要被一时的困难击倒。其实STL运用的模式相对统一，只要适应了它，从一个STL工具到另外一个工具，都不会有什么大的变化。

对于STL的使用，也广泛存在着两种观点。第一种认为STL的最大做用在于充当经典的数据结构和算法教材，由于它的源代码涉及了许多具体实现方面的问题。第二种则认为STL的初衷乃是为了简化设计，避免重复劳动，提升编程效率，所以应该是“应用至上”的，对于源代码则没必要深究。笔者则认为分析源代码和应用并不矛盾，经过分析源代码也能提升咱们对其应用的理解，固然根据具体的目的也能够有不一样的侧重。

第二部分：

暂且举几个很是容易理解的程序源码：

 

#include  < iostream >
#include  < vector >
using   namespace  std;
int  main(){
    vector < int > vi;
     int  a;
     while ( true )
    {
    cout << " 输入一个整数，按0中止输入： " ;
    cin >> a;
     if (a == 0 )
     break ;
    vi.push_back(a);   
    vector < int > ::iterator iter;
     for (iter = vi.begin();iter != vi.end(); ++ iter)
    cout <<* iter;      
    }
     return   0 ;
    }

 

 

#include  < iostream >  
#include  < string >
#include  < vector >  
using   namespace  std; 
int  main(){
string  str = " shiyang " ; 
vector  < string >  vecstr; 
vecstr.push_back(str);
vector  < string >  ::iterator iter =  vecstr.begin(); 
cout <<* iter << endl;
return   0 ;
}

 

 

#include    < stdlib.h >    
#include    < windows.h >    
#include    < conio.h >    
#include    < map >     // STL
#include    < functional >   // STL  
#include    < algorithm >     // STL
#include    < iostream >    
using   namespace  std;   
typedef  map < int , int *>  m_iip;   
typedef  map < int , char *>  m_icp;   
class   f_c{   
   int  _i;   
   public :   
  f_c( int  i):_i(i){
          
  }   
   void   operator ()(m_iip::value_type ite)   
  {   
  cout << _i ++<< " \t " << ite.first << "  shi " << endl;   
  }   
   void   operator ()(m_icp::value_type ite)  
  {   
  cout << _i ++<< " \t " << ite.first << "  yang " << endl;  
  }   
  };   
   void  f( int  i, int  c)   
  {   
      
  }   
   int  main( int  argc, char *  argv[]){
  m_iip  iip;   
  m_icp  icp;   
   int  i = 0 ;   
  iip.insert(make_pair( 34 , & i));   
  iip.insert(make_pair( 67 , & i));   
  iip.insert(make_pair( 5 , & i));   
  iip.insert(make_pair( 342 , & i));    
   char  d = 0 ;   
  icp.insert(make_pair( 12 , & d));   
  icp.insert(make_pair( 54 , & d));   
  icp.insert(make_pair( 6 , & d));   
  icp.insert(make_pair( 92 , & d));   
  for_each(iip.begin(),iip.end(),f_c( 8 ));   
  for_each(icp.begin(),icp.end(),f_c( 65 )); //    
   return   0 ;   
  }

 

 

#include  < iostream >
#include  < list >
#include  < numeric >
#include  < algorithm >
using   namespace  std;
// 建立一个list容器的实例LISTINT
typedef list < int >  LISTINT;

// 建立一个list容器的实例LISTCHAR
typedef list < int >  LISTCHAR;

int  main(){
     // --------------------------
     // 用list容器处理整型数据
     // --------------------------
     // 用LISTINT建立一个名为listOne的list对象
    LISTINT listOne;
     // 声明i为迭代器
    LISTINT::iterator i;

     // 从前面向listOne容器中添加数据
    listOne.push_front ( 2 );
    listOne.push_front ( 1 );

     // 从后面向listOne容器中添加数据
    listOne.push_back ( 3 );
    listOne.push_back ( 4 );

     // 从前向后显示listOne中的数据
    cout << " listOne.begin()--- listOne.end(): " << endl;
     for  (i  =  listOne.begin(); i  !=  listOne.end();  ++ i)
        cout  <<   * i  <<   "   " ;
    cout  <<  endl;

     // 从后向前显示listOne中的数据
LISTINT::reverse_iterator ir;
    cout << " listOne.rbegin()---listOne.rend(): " << endl;
     for  (ir  = listOne.rbegin(); ir != listOne.rend();ir ++ ) {
        cout  <<   * ir  <<   "   " ;
    }
    cout  <<  endl;

     // 使用STL的accumulate(累加)算法
     int  result  =  accumulate(listOne.begin(), listOne.end(), 0 );
    cout << " Sum= " << result << endl;
    cout << " ------------------ " << endl;

     // --------------------------
     // 用list容器处理字符型数据
     // --------------------------

     // 用LISTCHAR建立一个名为listOne的list对象
    LISTCHAR listTwo;
     // 声明i为迭代器
    LISTCHAR::iterator j;

     // 从前面向listTwo容器中添加数据
    listTwo.push_front ( ' A ' );
    listTwo.push_front ( ' B ' );

     // 从后面向listTwo容器中添加数据
    listTwo.push_back ( ' x ' );
    listTwo.push_back ( ' y ' );

     // 从前向后显示listTwo中的数据
    cout << " listTwo.begin()---listTwo.end(): " << endl;
     for  (j  =  listTwo.begin(); j  !=  listTwo.end();  ++ j)
        cout  <<   char ( * j)  <<   "   " ;
    cout  <<  endl;

     // 使用STL的max_element算法求listTwo中的最大元素并显示
    j = max_element(listTwo.begin(),listTwo.end());
    cout  <<   " The maximum element in listTwo is:  " << char ( * j) << endl;
}

 

 

#include  < iostream >
#include  < list >

using   namespace  std;
typedef list < int >  INTLIST;

// 从前向后显示list队列的所有元素
void  put_list(INTLIST list,  char   * name)
{
    INTLIST::iterator plist;

    cout  <<   " The contents of  "   <<  name  <<   "  :  " ;
     for (plist  =  list.begin(); plist  !=  list.end(); plist ++ )
        cout  <<   * plist  <<   "   " ;
    cout << endl;
}

// 测试list容器的功能
int  main(){
// list1对象初始为空
    INTLIST list1;   
     // list2对象最初有10个值为6的元素 
    INTLIST list2( 10 , 6 ); 
     // list3对象最初有9个值为6的元素 
    INTLIST list3(list2.begin(), -- list2.end()); 

     // 声明一个名为i的双向迭代器
    INTLIST::iterator i;

     // 从前向后显示各list对象的元素
    put_list(list1, " list1 " );
    put_list(list2, " list2 " );
    put_list(list3, " list3 " );
    
// 从list1序列后面添加两个元素
list1.push_back( 2 );
list1.push_back( 4 );
cout << " list1.push_back(2) and list1.push_back(4): " << endl;
    put_list(list1, " list1 " );

// 从list1序列前面添加两个元素
list1.push_front( 5 );
list1.push_front( 7 );
cout << " list1.push_front(5) and list1.push_front(7): " << endl;
    put_list(list1, " list1 " );

// 在list1序列中间插入数据3个9 
list1.insert( ++ list1.begin(), 3 , 9 );
cout << " list1.insert(list1.begin(),3,9): " << endl;
    put_list(list1, " list1 " );

// 测试引用类函数
cout << " list1.front()= " << list1.front() << endl;
cout << " list1.back()= " << list1.back() << endl;

// 从list1序列的先后各移去一个元素
list1.pop_front();
list1.pop_back();
cout << " list1.pop_front() and list1.pop_back(): " << endl;
    put_list(list1, " list1 " );

// 清除list1中的第2个元素
list1.erase( ++ list1.begin());
cout << " list1.erase(++list1.begin()): " << endl;
    put_list(list1, " list1 " );

// 对list2赋值并显示
list2.assign( 8 , 1 );
cout << " list2.assign(8,1): " << endl;
    put_list(list2, " list2 " );

// 显示序列的状态信息
cout << " list1.max_size():  " << list1.max_size() << endl;
cout << " list1.size():  " << list1.size() << endl;
cout << " list1.empty():  " << list1.empty() << endl;

// list序列容器的运算
    put_list(list1, " list1 " );
    put_list(list3, " list3 " );
cout << " list1>list3:  " << (list1 > list3) << endl;
cout << " list1<list3:  " << (list1 < list3) << endl;

// 对list1容器排序
list1.sort();
    put_list(list1, " list1 " );
    
// 结合处理
list1.splice( ++ list1.begin(), list3);
    put_list(list1, " list1 " );
    put_list(list3, " list3 " ); 
}

 

第三部分：

50条忠告：（其中有几条以为写的不够贴切，因此删了，发了余下的部分）

 

1.把C++当成一门新的语言学习；

2.看《Thinking In C++》，不要看《C++变成死相》；

3.看《The C++ Programming Language》和《Inside The C++ Object Model》,不要由于他们很难而咱们本身是初学者因此就不看；

4.不要被VC、BCB、BC、MC、TC等词汇所迷惑——他们都是集成开发环境，而咱们要学的是一门语言；

5.不要放过任何一个看上去很简单的小编程问题——他们每每并不那么简单，或者能够引申出不少知识点；

6.会用Visual C++，并不说明你会C++；

7.学class并不难，template、STL、generic programming也不过如此——难的是长期坚持实践和竭尽全力的博览群书；

8.若是不是天才的话，想学编程就不要想玩游戏——你觉得你作到了，其实你的C++水平并无和你通关的能力一块儿变高——其实能够时刻记住：学C++是为了编游戏的；

9.看Visual C++的书，是学不了C++语言的；  

16.把时髦的技术挂在嘴边，还不如把过期的技术记在内心；

18.学习编程最好的方法之一就是阅读源代码；

19.在任什么时候刻都不要认为本身手中的书已经足够了；

20.请阅读《The Standard C++ Bible》(中文版：标准C++宝典)，掌握C++标准；

21.看得懂的书，请仔细看；看不懂的书，请硬着头皮看；

22.别期望看第一遍书就能记住和掌握什么——请看第二遍、第三遍；

23.请看《Effective C++》和《More Effective C++》以及《Exceptional C++》；

24.不要停留在集成开发环境的摇篮上，要学会控制集成开发环境，还要学会用命令行方式处理程序；

25.和别人一块儿讨论有意义的C++知识点，而不是争吵XX行不行或者YY与ZZ哪一个好；

26.请看《程序设计实践》，并严格的按照其要求去作；

27.不要由于C和C++中有一些语法和关键字看上去相同，就认为它们的意义和做用彻底同样；

28.C++毫不是所谓的C的“扩充”——若是C++一开始就起名叫Z语言，你必定不会把C和Z语言联系得那么紧密；

29.请不要认为学过XX语言再改学C++会有什么问题——你只不过又在学一门全新的语言而已；

30.读完了《Inside The C++ Object Model》之后再来认定本身是否是已经学会了C++；

31.学习编程的秘诀是：编程，编程，再编程；

32.请留意下列书籍：《C++面向对象高效编程（C++ Effective Object-Oriented Software Construction）》《面向对象软件构造(Object-Oriented Software Construction)》《设计模式（Design Patterns）》《The Art of Computer Programming》； 

34.请把书上的程序例子亲手输入到电脑上实践，即便配套光盘中有源代码；

35.把在书中看到的有意义的例子扩充；

36.请重视C++中的异常处理技术，并将其切实的运用到本身的程序中；

37.常常回顾本身之前写过的程序，并尝试重写，把本身学到的新知识运用进去；

38.不要漏掉书中任何一个练习题——请所有作完并记录下解题思路；

39.C++语言和C++的集成开发环境要同时学习和掌握；

40.既然决定了学C++,就请坚持学下去，由于学习程序设计语言的目的是掌握程序设计技术，而程序设计技术是跨语言的；

41.就让C++语言的各类平台和开发环境去激烈的竞争吧，咱们要以学习C++语言自己为主；

42.当你写C++程序写到一半却发现本身用的方法很拙劣时，请不要立刻停手；请尽快将余下的部分粗略的完成以保证这个设计的完整性，而后分析本身的错误并从新设计和编写（参见43）；

43.别心急，设计C++的class确实不容易；本身程序中的class和本身的class设计水平是在不断的编程实践中完善和发展的；

44.决不要由于程序“很小”就不遵循某些你不熟练的规则——好习惯是培养出来的，而不是一次记住的；

45.每学到一个C++难点的时候，尝试着对别人讲解这个知识点并让他理解——你能讲清楚才说明你真的理解了；

46.记录下在和别人交流时发现的本身忽视或不理解的知识点；

47.请不断的对本身写的程序提出更高的要求,哪怕你的程序版本号会变成Version 100.XX；

48.保存好你写过的全部的程序——那是你最好的积累之一；

49.请不要作浮躁的人；

50.请热爱C++!

第四部分：

C++头文件一览
C、传统 C++

#include <assert.h>　　　　设定插入点
#include <ctype.h>　　　　字符处理
#include <errno.h>　　　　 定义错误码
#include <float.h>　　　　浮点数处理
#include <fstream.h>　　　文件输入／输出
#include <iomanip.h>　　　 参数化输入／输出
#include <iostream.h>　　　数据流输入／输出
#include <limits.h>　　　　定义各类数据类型最值常量
#include <locale.h>　　　　定义本地化函数
#include <math.h>　　　　　定义数学函数
#include <stdio.h>　　　　定义输入／输出函数
#include <stdlib.h>　　　　定义杂项函数及内存分配函数
#include <string.h>　　　　字符串处理
#include <strstrea.h>　　　基于数组的输入／输出
#include <time.h>　　　　　定义关于时间的函数
#include <wchar.h>　　　　 宽字符处理及输入／输出
#include <wctype.h>　　　　宽字符分类

标准 C++　

#include <algorithm>　　　  通用算法
#include <bitset>　　　　　 位集容器
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>　　　　 复数类
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>　　　　　 双端队列容器
#include <exception>　　　 异常处理类
#include <fstream>
#include <functional>　　　 定义运算函数（代替运算符）
#include <limits>
#include <list>　　　　　　 线性列表容器
#include <map>　　　　　　 映射容器
#include <iomanip>
#include <ios>　　　　　　基本输入／输出支持
#include <iosfwd>　　　　输入／输出系统使用的前置声明
#include <iostream>
#include <istream>　　　　 基本输入流
#include <ostream>　　　　 基本输出流
#include <queue>　　　　　  队列容器
#include <set>　　　　　　 集合容器
#include <sstream>　　　　 基于字符串的流
#include <stack>　　　　　 堆栈容器　　　　
#include <stdexcept>　　　 标准异常类
#include <streambuf>　　　底层输入／输出支持
#include <string>　　　　　字符串类
#include <utility>　　　　 通用模板类
#include <vector>　　　　 动态数组容器
#include <cwchar>
#include <cwctype>

C99 增长

#include <complex.h>　　复数处理#include <fenv.h>　　　　浮点环境#include <inttypes.h>　　整数格式转换#include <stdbool.h>　　 布尔环境#include <stdint.h>　　　整型环境#include <tgmath.h>　　通用类型数学宏