C++:STL标准入门汇总

素颜马尾好姑娘i 2022-08-07 03:44 94阅读 0赞

学无止境！！！

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

一、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>**。

二、算法

大家都能取得的一个共识是函数库对数据类型的选择对其可重用性起着至关重要的作用。举例来说，一个求方根的函数，在使用浮点数作为其参数类型的情况下的可重用性肯定比

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

算法。它是在一个有效的框架中完成这些算法的——你可以将所有的类型划分为少数的几类，然后就可以在模版的参数中使用一种类型替换掉同一种类中的其他类型。

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

，只要我们熟悉了STL之后，许多代码可以被大大的化简，只需要通过调用一两个算法模板，就可以完成所需要的功能并大大地提升效率。

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

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

** **

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

** **

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

三、容器

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

经典的数据结构数量有限，但是我们常常重复着一些为了实现向量、链表等结构而编写的代码，这些代码都十分相似，只是为了适应不同数据的变化而在细节上有所出入。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>**

四、迭代器

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

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

。

概括来说，迭代器在STL中用来将算法和容器联系起来，起着一种黏和剂的作用。几乎STL提供的所有算法都是通过迭代器存取元素序列进行工作的，每一个容器都定义了其本身所专有的迭代器，用以存取容器中的元素。

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

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

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

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

对于STL的使用，也普遍存在着两种观点。第一种认为STL的最大作用在于充当经典的数据结构和算法教材，因为它的源代码涉及了许多具体实现方面的问题。第二种则认为STL的初衷乃是为了简化设计，避免重复劳动，提高[编程][Link 1]效率，因此应该是“应用至上”的，对于源代码则不必深究。笔者则认为分析源代码和应用并不矛盾，通过分析源代码也能提高我们对其应用的理解，当然根据具体的目的也可以有不同的侧重。

第二部分：

暂且举几个非常容易理解的程序源码：

![复制代码][copycode.gif]

\#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 ;  
    \}

![复制代码][copycode.gif]

\#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 ;  
\}

![复制代码][copycode.gif]

\#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 ;     
  \}

![复制代码][copycode.gif]

\#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;  
\}

![复制代码][copycode.gif]

\#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 " );   
\}

![复制代码][copycode.gif]

第三部分：

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>　　通用类型数学宏

[Link 1]: http://www.zaoxue.com/
[copycode.gif]: /images/20220805/ef055cde4510442c8688c0c51b4bd42e.png