C++STL标准入门汇总
黑马程序员C语言教程:C++ STL 一般总结

传智播客C/C++培训专家:C++ STL 一般总结分类:C/C++一、一般介绍STL(Standard Template Library),即标准模板库,是一个具有工业强度的,高效的C++程序库。
它被容纳于C++标准程序库(C++ Standard Library)中,是ANSI/ISO C++标准中最新的也是极具革命性的一部分。
该库包含了诸多在计算机科学领域里所常用的基本数据结构和基本算法。
为广大C++程序员们提供了一个可扩展的应用框架,高度体现了软件的可复用性。
从逻辑层次来看,在STL中体现了泛型化程序设计的思想(generic programming),引入了诸多新的名词,比如像需求(requirements),概念(concept),模型(model),容器(container),算法(algorithmn),迭代子(iterator)等。
与OOP(object-oriented programming)中的多态(polymorphism)一样,泛型也是一种软件的复用技术;从实现层次看,整个STL是以一种类型参数化(type parameterized)的方式实现的,这种方式基于一个在早先C++标准中没有出现的语言特性--模板(template)。
如果查阅任何一个版本的STL源代码,你就会发现,模板作为构成整个STL的基石是一件千真万确的事情。
除此之外,还有许多C++的新特性为STL的实现提供了方便;二、STL的六大组件•容器(Container),是一种数据结构,如list,vector,和deques ,以模板类的方法提供。
为了访问容器中的数据,可以使用由容器类输出的迭代器;•迭代器(Iterator),提供了访问容器中对象的方法。
例如,可以使用一对迭代器指定list或vector中的一定范围的对象。
迭代器就如同一个指针。
事实上,C++的指针也是一种迭代器。
但是,迭代器也可以是那些定义了operator*()以及其他类似于指针的操作符地方法的类对象;•算法(Algorithm),是用来操作容器中的数据的模板函数。
C++ 标准模板库(STL)学习总结

C++标准模板库(STL)顺序性容器1.C++ Vector(向量容器)vector提供如下函数或操作:clear() 移除容器中所有数据empty() 判断容器是否为空erase(pos) 删除pos位置的数据erase(beg,end) 删除[beg,end)区间的数据front() 传回第一个数据back()返回vector中末尾元素的引用data()返回指向vector内存的指针insert(pos,elem) 在pos位置插入一个elem拷贝pop_back() 删除最后一个数据push_back(elem) 在尾部加入一个数据resize(num) 重新设置该容器的大小size() 返回容器中实际数据的个数max_size()函数返回vector能够容纳的最大元素个数begin() 返回指向容器第一个元素的迭代器end() 返回指向容器最后一个元素的迭代器capacity()返回vector中实际分配的内存大小reverse()改变vector的容量大小,当vector的容量设定时,vector的容量不会因此动态分配operator[ ]()获取vector中元素,这个和C中获取数组元素一样at()获取vector中的元素,这个和[]的作用一样,不过和[]不同的是,at()函数要对数组的边界进行检查,如果越界就会抛出异常,但是[]不会。
2.C++ List(链表)Lists将元素按顺序储存在链表中. 与向量(vectors)相比, 它允许快速的插入和删除,但是随机访问却比较慢.assign() 给list赋值back() 返回最后一个元素begin() 返回指向第一个元素的迭代器clear() 删除所有元素empty() 如果list是空的则返回trueend() 返回末尾的迭代器erase() 删除一个元素front() 返回第一个元素get_allocator() 返回list的配置器insert() 插入一个元素到list中max_size() 返回list能容纳的最大元素数量merge() 合并两个listpop_back() 删除最后一个元素pop_front() 删除第一个元素push_back() 在list的末尾添加一个元素push_front() 在list的头部添加一个元素rbegin() 返回指向第一个元素的逆向迭代器remove() 从list删除元素remove_if() 按指定条件删除元素rend() 指向list末尾的逆向迭代器resize() 改变list的大小reverse() 把list的元素倒转size() 返回list中的元素个数sort() 给list排序splice() 合并两个listswap() 交换两个listunique() 删除list中重复的元素3.C++ deque(双向队列)容器deque和vector非常相似,操作函数基本一致。
C++:STL标准入门汇总

C++:STL标准⼊门汇总学⽆⽌境第⼀部分:(参考百度百科)⼀、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常用总结

STL常用总结Last Update (July. 2014) by WINGACM/ICPC 竞赛之STL 简介一、关于STLSTL(Standard Template Library,标准模板库)是C++语言标准中的重要组成部分。
STL 以模板类和模板函数的形式为程序员提供了各种数据结构和算法的精巧实现,程序员如果能够充分地利用STL,可以在代码空间、执行时间和编码效率上获得极大的好处。
STL 大致可以分为三大类:算法(algorithm)、容器(container)、迭代器(iterator)。
STL 容器是一些模板类,提供了多种组织数据的常用方法,例如vector(向量,类似于数组)、list(列表,类似于链表)、deque(双向队列)、set(集合)、map(映象)、stack(栈)、queue(队列)、priority_queue(优先队列)等,通过模板的参数我们可以指定容器中的元素类型。
STL 算法是一些模板函数,提供了相当多的有用算法和操作,从简单如for_each(遍历)到复杂如stable_sort(稳定排序)。
STL 迭代器是对C 中的指针的一般化,用来将算法和容器联系起来。
几乎所有的STL 算法都是通过迭代器来存取元素序列进行工作的,而STL 中的每一个容器也都定义了其本身所专有的迭代器,用以存取容器中的元素。
有趣的是,普通的指针也可以像迭代器一样工作。
熟悉了STL 后,你会发现,很多功能只需要用短短的几行就可以实现了。
通过STL,我们可以构造出优雅而且高效的代码,甚至比你自己手工实现的代码效果还要好。
STL 的另外一个特点是,它是以源码方式免费提供的,程序员不仅可以自由地使用这些代码,也可以学习其源码,甚至按照自己的需要去修改它。
下面是用STL 写的题Ugly Numbers 的代码:#include <iostream>#include <queue>using namespace std;typedef pair<unsigned long, int> node_type;int main(){unsigned long result[1500];priority_queue< node_type, vector<node_type>, greater<node_type> >Q;Q.push( make_pair(1, 2) );for (int i=0; i<1500; i++){node_type node = Q.top(); Q.pop();switch(node.second){case 2: Q.push( make_pair(node.first*2, 2) );case 3: Q.push( make_pair(node.first*3, 3) );case 5: Q.push( make_pair(node.first*5, 5) );}result[i] = node.first;}int n;cin >> n;while (n>0){cout << result[n-1] << endl;cin >> n;}return 0;}在ACM 竞赛中,熟练掌握和运用STL 对快速编写实现代码会有极大的帮助。
C++STL标准库指南

C++ STL标准库指南C++ STL 标准库指南C++ STL(Standard Template Library)是一种重要的 C++ 库,它提供了一组通用的数据结构和算法工具,便于 C++ 程序员开发高效、稳定和可移植的代码。
STL 标准库由三个主要部分组成:容器、算法和迭代器。
容器容器是 STL 标准库的核心组成部分。
容器是存储数据的对象,它包括了各种数据结构,如数组、链表、向量、映射等。
C++ STL 标准库中提供了许多不同的容器类型,每个容器有其特定的使用场景和性能特征。
常见的容器类型包括:1. 向量(vector)向量是一个元素列表,支持随机访问的迭代器。
向量的大小可以动态调整,它会自动管理内存,可以高效地进行内存操作。
向量是一个非常常用的容器类型,可以用于存储单个类型的元素或自定义结构体。
2. 链表(list)链表是一个元素序列,每个元素都是由前一个元素和后一个元素组成的节点链。
链表不支持随机访问,但是支持高效插入和删除操作。
链表可以用于实现队列、栈等数据结构。
3. 映射(map)映射是一组键值对,每个键对应一个值。
映射中的键是唯一的,如果添加一个已经存在的键,则会替换对应的值。
映射提供了方便的查询和插入操作,可以用于实现字典、数据库等数据结构。
算法算法是 STL 标准库的另一个重要组成部分。
它提供了一组通用的算法,可以用于操作容器、迭代器以及其他数据类型。
STL 提供了大量的算法,包括排序、查找、字符串操作等,为开发高效的 C++ 程序提供了强大的工具支持。
常见的算法类型包括:1. 排序算法排序算法是一组重要的算法,可以用于对容器中的元素进行排序。
STL 标准库中提供了多种排序算法,包括快速排序、归并排序、堆排序等,可以根据不同的性能要求选择不同的算法。
2. 查找算法查找算法是一组用于在容器中查找元素的算法。
STL 标准库中提供了多种查找算法,包括二分查找、线性查找等,可以根据不同的复杂度和数据类型选择合适的算法。
c++ stl 标准

c++ stl 标准C++ STL (Standard Template Library) 是 C++ 标准库的一部分,它提供了一组通用的数据结构和算法,用于解决常见的编程问题。
STL 包括容器(如 vector、list、set、map 等)、算法(如 sort、find、copy 等)以及其他有用的组件。
以下是 C++ STL 的一些主要组件:1. 容器(Containers):STL 提供了多种数据结构,如 vector(动态数组)、list(双向链表)、set(集合)、map(关联数组)等。
这些容器不仅提供了常用的数据操作(如插入、删除、查找等),还隐藏了底层的实现细节,使得程序员可以专注于解决问题而不是管理数据结构。
2. 算法(Algorithms):STL 包含许多算法,这些算法可以在容器上执行。
例如,sort 可以对 vector 中的元素进行排序,find 可以查找特定元素。
算法与容器配合使用,使得程序更加高效。
3. 迭代器(Iterators):迭代器是一种设计模式,它允许程序员通过迭代器遍历容器中的元素,而无需关心底层的数据结构。
这增加了代码的灵活性,因为你可以在不改变现有代码的情况下更改底层的数据结构。
4. 函数对象(Function Objects)和 Lambda 表达式:STL 允许程序员将函数作为参数传递给其他函数或对象。
这使得算法可以更加通用和灵活。
Lambda 表达式是 C++11 引入的一种简洁的函数对象表示方式。
5. 适配器(Adapters):适配器是一种设计模式,用于改变一个类的接口,使其更符合另一个类的需求。
STL 提供了一些适配器,例如stack(用于在任何其他容器上模拟栈的行为)、queue(用于在任何其他容器上模拟队列的行为)等。
6. 分配器(Allocators):分配器用于管理内存。
STL 中的容器可以与不同的分配器一起使用,以改变内存管理策略。
C++STL学习经典
C++语言学习之STL 的组成STL有三大核心部分:容器(Container)、算法(Algorithms)、迭代器(Iterator),容器适配器(container adaptor),函数对象(functor),除此之外还有STL其他标准组件。
通俗的讲:容器:装东西的东西,装水的杯子,装咸水的大海,装人的教室……S TL里的容器是可容纳一些数据的模板类。
算法:就是往杯子里倒水,往大海里排污,从教室里撵人……STL里的算法,就是处理容器里面数据的方法、操作。
迭代器:往杯子里倒水的水壶,排污的管道,撵人的那个物业管理人员……STL 里的迭代器:遍历容器中数据的对象。
对存储于容器中的数据进行处理时,迭代器能从一个成员移向另一个成员。
他能按预先定义的顺序在某些容器中的成员间移动。
对普通的一维数组、向量、双端队列和列表来说,迭代器是一种指针。
下面让我们来看看专家是怎么说的:容器(container):容器是数据在内存中组织的方法,例如,数组、堆栈、队列、链表或二叉树(不过这些都不是STL标准容器)。
STL中的容器是一种存储T(Template)类型值的有限集合的数据结构,容器的内部实现一般是类。
这些值可以是对象本身,如果数据类型T代表的是Class的话。
算法(algorithm):算法是应用在容器上以各种方法处理其内容的行为或功能。
例如,有对容器内容排序、复制、检索和合并的算法。
在STL中,算法是由模板函数表现的。
这些函数不是容器类的成员函数。
相反,它们是独立的函数。
令人吃惊的特点之一就是其算法如此通用。
不仅可以将其用于STL容器,而且可以用于普通的C++数组或任何其他应用程序指定的容器。
迭代器(iterator):一旦选定一种容器类型和数据行为(算法),那么剩下唯一要他做的就是用迭代器使其相互作用。
可以把达代器看作一个指向容器中元素的普通指针。
可以如递增一个指针那样递增迭代器,使其依次指向容器中每一个后继的元素。
STL(C++标准模板库) 入门
呼叫方式:MyMin( ary, ary+n, LessThen() );
C++
Generic Algorithm 「泛型」「算法」
联合大学资工系 周念湘 nschou@.tw
1
Generic Algorithm(泛型算法)
泛型:广泛适用各种「资料型别」或「容器」 演算法:动作,运算 「容器 容器」透过一对「迭代器 迭代器」与算法 算法结合
一对迭代器标出容器的作用范围 一对迭代器 作用范围 「仿函示」 仿函示」或「函示指标」 函示指标」可改变算法「语意 语意」
4
sequence
sorted
Generic Algorithm
联合大学资工系 周念湘 nschou@.tw
5
set/multiset的区别: 资料是否重复?!
Gchou@.tw
6
set的内部结构:binary search tree
st st st
A C B D
STL预先定义之 function obj.
A
B
C
D
D
C
B
A
Generic Algorithm
联合大学资工系 周念湘 nschou@.tw
16
泛型演算法举例:vector
#include <algorithm> #include <vector> vector<int> dict; vector<int>::iterator pos; for( i=0, pos =dict.begin(); pos !=dict.end(); ++ pos ) dict.push_back(++i); sort( pos.begin(), pos.end() ); for(pos =dict.begin(); pos !=dict.end(); ++ pos ) cout << * pos << " ";
C++STL入门
迭代器范围
使用一对迭代器标记迭代器范围,分别指向同一个容器 的两个元素或者超出末端的下一位置。 左闭合区间:[first,last),范围表示从first开始,到last 结束。first必须在last的前面或者first等于last。 while(first!=last) {++first; } first和last必须属于同一个容器
它们差别在于访问元素的方式,以及添加或者删除元素的 相关操作的运行代价。
6
迭代器(Iterator)
Operator *
返回当前位置上元素。如果该元素有成员,直接用 Operator->取
Operator ++
将迭代器前进值下一元素
Operator == 和 Operator !=
判断两个迭代器是否指向同一位置
分配和初始化指定数目的元素
可以显示指定一个容器大小和元素初始化 值 容器大小可以是常量或非常量表达式 list<string> sList(10, "abc"); int iSize=64; list<string> sList(iSize, "abc");
容器内元素的类型约束
必须满足两个约束: 元素类型必须支持赋值运算 元素类型的对象必须可以复制 元素是类的情况: 假如类Foo没有默认构造函数,但提供带int型的构造函数 vector<Foo> f; vector<Foo> f1(10); vector<Foo> f2(10,2); 元素不能是引用 容器的容器 vector< vector<string> > lines;
关于C++标准模板库(STL)的一些基本使用
关于C++标准模板库(STL)的⼀些基本使⽤vectorvector可以理解成变长数组,即长度根据需要⽽⾃动改变的数组头⽂件:#include <vector>定义:vector<typename>name;vector内可以通过下标或者迭代器(iterator)访问(只有vector和string才允许使⽤v.begin()+3这种迭代器加整数的写法) v.push_back(value) 时间复杂度:O(1)v.pop_back() 时间复杂度:O(1)v.size() 返回的是unsigned类型时间复杂度:O(1)v.clear() 时间复杂度:O(N) N是vector中元素的个数v.insert(it,value) 时间复杂度:O(N)v.erase(it) 时间复杂度:O(N)v.erase(first,last) 即删除[first,last)内元素时间复杂度:O(N)setset可以理解成集合,⼀个内部⾃动有序且不含重复元素的容器头⽂件:#include <set>定义:set<typename>name;set只能通过迭代器访问s.insert(value) 时间复杂度:O(logN) N为set内元素个数s.find(value) 时间复杂度:O(logN) N为set内元素个数s.erase(it) 时间复杂度:O(1)s.erase(value) 时间复杂度:O(logN)s.erase(first,last) 时间复杂度:O(last−first)s.size() 时间复杂度:O(1)s.clear() 时间复杂度:O(N)set中元素是唯⼀的,如果需要处理不唯⼀的情况,则需要使⽤multiset。
另外,C++11标准中还增加了unordered_set,以散列代替set内部的红⿊树(⼀种⾃平衡⼆叉查找树),使其可以⽤来处理只去重但不排序的需求,速度⽐set要快得多。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
学无止境!!!第一部分:(参考百度百科)一、STL简介STL(Standard Template Library,标准模板库)是惠普实验室开发的一系列软件的统称。
它是由Alexander Stepanov、Me ng 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的三个部分算法、容器和迭代器三部分是互相牵制或者说是紧密结合的。
从概念上讲最基础的部分是迭代器,可是直接学习迭代器会遇到许多抽象枯燥和繁琐的细节,然而不真正理解迭代器又是无法直接进入另两部分的学习的(至少对剖析源码来说是这样)。
可以说,适应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;}return0;}#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;return0;}#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));// return0;}#include <iostream>#include <list>#include <numeric>#include <algorithm>using namespace std;//创建一个list容器的实例LISTINTtypedef list<int> LISTINT;//创建一个list容器的实例LISTCHARtypedef 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个9list1.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 Progr amming》;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>通用类型数学宏。