《第十一章标准模板类库STL》由会员分享，可在线阅读，更多相关《第十一章标准模板类库STL（79页珍藏版）》请在金锄头文库上搜索。
1、 11.1 11.1 基本数据结构知识基本数据结构知识基本数据结构知识基本数据结构知识 11.211.2泛型程序设计与标准模板类库泛型程序设计与标准模板类库泛型程序设计与标准模板类库泛型程序设计与标准模板类库STLSTL简介简介简介简介 11.3 11.3 向量向量向量向量 11.4 11.4 链表类的使用链表类的使用链表类的使用链表类的使用 11.5 11.5 双端队列双端队列双端队列双端队列 11.6 11.6 栈与队列栈与队列栈与队列栈与队列 11.7 11.7 集合集合集合集合第第 11 章章标准模板类库标准模板类库STLSTL C+C+语言的标准模板类库语言的标准模板类库语言的标准模
2、板类库语言的标准模板类库STL(Standard Template Library)STL(Standard Template Library)已经成为一已经成为一已经成为一已经成为一个标准，它是一个基于模板的群性类库，包含群体类（链表、向量、栈、个标准，它是一个基于模板的群性类库，包含群体类（链表、向量、栈、个标准，它是一个基于模板的群性类库，包含群体类（链表、向量、栈、个标准，它是一个基于模板的群性类库，包含群体类（链表、向量、栈、队列、集合、映象），算法队列、集合、映象），算法队列、集合、映象），算法队列、集合、映象），算法( (排序、查找排序、查找排序、查找排序、查找) )以及迭代子以
3、及迭代子以及迭代子以及迭代子( (iteratoriterator) )。本章将本章将本章将本章将着重介绍着重介绍着重介绍着重介绍STLSTL的使用。的使用。的使用。的使用。实现了数组和链表，它们属于实现了数组和链表，它们属于实现了数组和链表，它们属于实现了数组和链表，它们属于线性群体线性群体线性群体线性群体。还有两种特殊的线性群体：。还有两种特殊的线性群体：。还有两种特殊的线性群体：。还有两种特殊的线性群体：栈和栈和栈和栈和队列队列队列队列。Ele1Ele1Ele2Ele2ElenElen入栈入栈入栈入栈出栈出栈出栈出栈栈顶栈顶栈顶栈顶栈底栈底栈底栈底图图图图栈的示意图栈的示意图栈的示意图栈
4、的示意图 栈是栈是栈是栈是只能从一端访问的线性群体只能从一端访问的线性群体只能从一端访问的线性群体只能从一端访问的线性群体，可以，可以，可以，可以访问的这一端称访问的这一端称访问的这一端称访问的这一端称栈顶栈顶栈顶栈顶，另一端称，另一端称，另一端称，另一端称栈底栈底栈底栈底。对栈。对栈。对栈。对栈顶位置的标记称为顶位置的标记称为顶位置的标记称为顶位置的标记称为栈顶指针栈顶指针栈顶指针栈顶指针，对栈底位置的，对栈底位置的，对栈底位置的，对栈底位置的标记称为标记称为标记称为标记称为栈底指针栈底指针栈底指针栈底指针。 向栈顶添加元素称为向栈顶添加元素称为向栈顶添加元素称为向栈顶添加元素称为“ “压入
5、栈压入栈压入栈压入栈” ”(push)(push)，删除栈顶元素称为删除栈顶元素称为删除栈顶元素称为删除栈顶元素称为“ “弹出栈弹出栈弹出栈弹出栈” ”(pop)(pop)。 栈中元素的添加和删除操作具有栈中元素的添加和删除操作具有栈中元素的添加和删除操作具有栈中元素的添加和删除操作具有“ “后进后进后进后进先出先出先出先出” ”（LIFOLIFO）的特性。的特性。的特性。的特性。【 11.1 11.1 基本数据结构知识基本数据结构知识基本数据结构知识基本数据结构知识】有一种限定的线性数据群体叫有一种限定的线性数据群体叫有一种限定的线性数据群体叫有一种限定的线性数据群体叫双端队列双端队列双端队
6、列双端队列，它类似于限定删除和插入操作都，它类似于限定删除和插入操作都，它类似于限定删除和插入操作都，它类似于限定删除和插入操作都必须在两端进行的链表。必须在两端进行的链表。必须在两端进行的链表。必须在两端进行的链表。 队列是一种特殊的线性群体。队列队列是一种特殊的线性群体。队列队列是一种特殊的线性群体。队列队列是一种特殊的线性群体。队列只能向一端添加元素只能向一端添加元素只能向一端添加元素只能向一端添加元素，从另一端删除，从另一端删除，从另一端删除，从另一端删除元素的线性群体，可以添加元素的一端称元素的线性群体，可以添加元素的一端称元素的线性群体，可以添加元素的一端称元素的线性群体，可以添加
7、元素的一端称队尾队尾队尾队尾，可以删除元素的一端称，可以删除元素的一端称，可以删除元素的一端称，可以删除元素的一端称队头队头队头队头。对队头位置的标记称为对队头位置的标记称为对队头位置的标记称为对队头位置的标记称为队头指针队头指针队头指针队头指针，对队尾位置的标记称为，对队尾位置的标记称为，对队尾位置的标记称为，对队尾位置的标记称为队尾指针队尾指针队尾指针队尾指针。 Ele1Ele1出队出队出队出队入队入队入队入队Ele2Ele2ElenElen队头队头队头队头队尾队尾队尾队尾非线性群体：集合和映射。非线性群体：集合和映射。非线性群体：集合和映射。非线性群体：集合和映射。集合集合集合集合由若干
8、个元素组成，对于一个指定的元素，由若干个元素组成，对于一个指定的元素，由若干个元素组成，对于一个指定的元素，由若干个元素组成，对于一个指定的元素，它或者属于该集合，或者不属于；可以对两个集合求交集和差等。它或者属于该集合，或者不属于；可以对两个集合求交集和差等。它或者属于该集合，或者不属于；可以对两个集合求交集和差等。它或者属于该集合，或者不属于；可以对两个集合求交集和差等。映射映射映射映射则则则则类似于字典的功能，如一个身份证号码可以映射为某个确定的人，图书馆类似于字典的功能，如一个身份证号码可以映射为某个确定的人，图书馆类似于字典的功能，如一个身份证号码可以映射为某个确定的人，图书馆类似于
9、字典的功能，如一个身份证号码可以映射为某个确定的人，图书馆中一本书的编号和这本书也是一个映射。中一本书的编号和这本书也是一个映射。中一本书的编号和这本书也是一个映射。中一本书的编号和这本书也是一个映射。 向队尾添加元素称为向队尾添加元素称为向队尾添加元素称为向队尾添加元素称为“ “入队入队入队入队” ”，删除队头元素称为，删除队头元素称为，删除队头元素称为，删除队头元素称为“ “出队出队出队出队” ”。队列中元素的添加和删除操作具有队列中元素的添加和删除操作具有队列中元素的添加和删除操作具有队列中元素的添加和删除操作具有“ “先进先出先进先出先进先出先进先出” ”（FIFOFIFO）的特性。的
10、特性。的特性。的特性。图图图图队列的逻辑结构示意图队列的逻辑结构示意图队列的逻辑结构示意图队列的逻辑结构示意图11.2.111.2.1泛型程序设计泛型程序设计泛型程序设计泛型程序设计 将程序写得尽可能通用将程序写得尽可能通用将程序写得尽可能通用将程序写得尽可能通用 将算法从特定的数据结构中抽象出来，成为通用的将算法从特定的数据结构中抽象出来，成为通用的将算法从特定的数据结构中抽象出来，成为通用的将算法从特定的数据结构中抽象出来，成为通用的 C+C+的模板为泛型程序设计奠定了关键的基础的模板为泛型程序设计奠定了关键的基础的模板为泛型程序设计奠定了关键的基础的模板为泛型程序设计奠定了关键的基础 S
11、TLSTL是泛型程序设计的一个范例是泛型程序设计的一个范例是泛型程序设计的一个范例是泛型程序设计的一个范例 容器容器容器容器(container)(container) 迭代器迭代器迭代器迭代器( (iteratoriterator) ) 算法（算法（算法（算法（algorithmsalgorithms） 函数对象（函数对象（函数对象（函数对象（function objectfunction object）【 11.211.2泛型程序设计泛型程序设计泛型程序设计泛型程序设计与标准模板类库与标准模板类库与标准模板类库与标准模板类库STLSTL简介简介简介简介】4命名空间（命名空间（命名空间（命名
12、空间（NamespaceNamespace） 一个命名空间将不同的标识符集合在一个命名作用域一个命名空间将不同的标识符集合在一个命名作用域一个命名空间将不同的标识符集合在一个命名作用域一个命名空间将不同的标识符集合在一个命名作用域（named scopenamed scope）内）内）内）内 为了解决命名冲突为了解决命名冲突为了解决命名冲突为了解决命名冲突 例如，声明一个命名空间例如，声明一个命名空间例如，声明一个命名空间例如，声明一个命名空间NSNS： namspacenamspace NS NS class File;class File; void Fun ();void Fun ();
13、 则引用标识符的方式如下，则引用标识符的方式如下，则引用标识符的方式如下，则引用标识符的方式如下， NS: File NS: File objobj; ; NS: Fun ();NS: Fun (); 没有声明命名空间的标识符都处于无名的命名空间中没有声明命名空间的标识符都处于无名的命名空间中没有声明命名空间的标识符都处于无名的命名空间中没有声明命名空间的标识符都处于无名的命名空间中概念和术语5命名空间（命名空间（命名空间（命名空间（NamespaceNamespace） 可以用可以用可以用可以用usingusing来指定命名空间来指定命名空间来指定命名空间来指定命名空间 例如，经过以下声明：
14、例如，经过以下声明：例如，经过以下声明：例如，经过以下声明：using using NS:FileNS:File; ;在当前作用域中就可以直接引用在当前作用域中就可以直接引用在当前作用域中就可以直接引用在当前作用域中就可以直接引用FileFile using namespace std;using namespace std;命名空间命名空间命名空间命名空间stdstd中所有标识符都可直接引用中所有标识符都可直接引用中所有标识符都可直接引用中所有标识符都可直接引用 在新的在新的在新的在新的C+C+标准程序库中，所有标识符都声明在命名空间标准程序库中，所有标识符都声明在命名空间标准程序库中，所有
15、标识符都声明在命名空间标准程序库中，所有标识符都声明在命名空间stdstd中，头文件都不使用扩展名中，头文件都不使用扩展名中，头文件都不使用扩展名中，头文件都不使用扩展名概念和术语6容器容器容器容器 容器类是容纳、包含一组元素或元素集合的对象。容器类是容纳、包含一组元素或元素集合的对象。容器类是容纳、包含一组元素或元素集合的对象。容器类是容纳、包含一组元素或元素集合的对象。 异类容器类与同类容器类异类容器类与同类容器类异类容器类与同类容器类异类容器类与同类容器类 顺序容器与关联容器顺序容器与关联容器顺序容器与关联容器顺序容器与关联容器 七种基本容器：七种基本容器：七种基本容器：七种基本容器：
16、向量（向量（向量（向量（vectorvector）、双端队列（）、双端队列（）、双端队列（）、双端队列（dequedeque）、列表（）、列表（）、列表（）、列表（listlist）、集）、集）、集）、集合（合（合（合（setset）、多重集合（）、多重集合（）、多重集合（）、多重集合（multisetmultiset）、映射（）、映射（）、映射（）、映射（mapmap）和多重）和多重）和多重）和多重映射（映射（映射（映射（multimapmultimap）概念和术语7容器的接口容器的接口容器的接口容器的接口 通用容器运算符通用容器运算符通用容器运算符通用容器运算符 =，!=!=， ，=， ，
17、=，= = 方法（函数）方法（函数）方法（函数）方法（函数） 迭代方法迭代方法迭代方法迭代方法 begin()begin()，end()end()，rbeginrbegin() ()，rend()rend() 访问方法访问方法访问方法访问方法 size()size()，max_sizemax_size() ()，swap()swap()，empty()empty()8适配器适配器适配器适配器 适配器是一种接口类适配器是一种接口类适配器是一种接口类适配器是一种接口类 为已有的类提供新的接口。为已有的类提供新的接口。为已有的类提供新的接口。为已有的类提供新的接口。 目的是简化、约束、使之安全、隐藏
18、或者改变被修改类目的是简化、约束、使之安全、隐藏或者改变被修改类目的是简化、约束、使之安全、隐藏或者改变被修改类目的是简化、约束、使之安全、隐藏或者改变被修改类提供的服务集合。提供的服务集合。提供的服务集合。提供的服务集合。 三种类型的适配器：三种类型的适配器：三种类型的适配器：三种类型的适配器： 容器适配器容器适配器容器适配器容器适配器 用来扩展用来扩展用来扩展用来扩展7 7种基本容器，它们和顺序容器相结合构成种基本容器，它们和顺序容器相结合构成种基本容器，它们和顺序容器相结合构成种基本容器，它们和顺序容器相结合构成栈、队列和优先队列容器栈、队列和优先队列容器栈、队列和优先队列容器栈、队列和
19、优先队列容器 迭代器适配器迭代器适配器迭代器适配器迭代器适配器 函数对象适配器。函数对象适配器。函数对象适配器。函数对象适配器。概念和术语9迭代器迭代器迭代器迭代器 迭代器是面向对象版本的指针，它们提供了访问容器、序列中每迭代器是面向对象版本的指针，它们提供了访问容器、序列中每迭代器是面向对象版本的指针，它们提供了访问容器、序列中每迭代器是面向对象版本的指针，它们提供了访问容器、序列中每个元素的方法。个元素的方法。个元素的方法。个元素的方法。概念和术语10算法算法算法算法 C+C+标准模板库中包括标准模板库中包括标准模板库中包括标准模板库中包括7070多个算法多个算法多个算法多个算法 其中包括
20、查找算法，排序算法，消除算法，记数算法，比较其中包括查找算法，排序算法，消除算法，记数算法，比较其中包括查找算法，排序算法，消除算法，记数算法，比较其中包括查找算法，排序算法，消除算法，记数算法，比较算法，变换算法，置换算法和容器管理等等。算法，变换算法，置换算法和容器管理等等。算法，变换算法，置换算法和容器管理等等。算法，变换算法，置换算法和容器管理等等。 这些算法的一个最重要的特性就是它们的统一性，并且可以广泛这些算法的一个最重要的特性就是它们的统一性，并且可以广泛这些算法的一个最重要的特性就是它们的统一性，并且可以广泛这些算法的一个最重要的特性就是它们的统一性，并且可以广泛用于不同的对象
21、和内置的数据类型。用于不同的对象和内置的数据类型。用于不同的对象和内置的数据类型。用于不同的对象和内置的数据类型。概念和术语11函数对象函数对象函数对象函数对象 一个行为类似函数的对象，它可以不需参数，也可以带有若一个行为类似函数的对象，它可以不需参数，也可以带有若一个行为类似函数的对象，它可以不需参数，也可以带有若一个行为类似函数的对象，它可以不需参数，也可以带有若干参数，其功能是获取一个值，或者改变操作的状态。干参数，其功能是获取一个值，或者改变操作的状态。干参数，其功能是获取一个值，或者改变操作的状态。干参数，其功能是获取一个值，或者改变操作的状态。 任何普通的函数和任何重载了调用运算符
22、任何普通的函数和任何重载了调用运算符任何普通的函数和任何重载了调用运算符任何普通的函数和任何重载了调用运算符operator()operator()的类的对的类的对的类的对的类的对象都满足函数对象的特征象都满足函数对象的特征象都满足函数对象的特征象都满足函数对象的特征 STLSTL中也定义了一些标准的函数对象，如果以功能划分，可中也定义了一些标准的函数对象，如果以功能划分，可中也定义了一些标准的函数对象，如果以功能划分，可中也定义了一些标准的函数对象，如果以功能划分，可以分为算术运算、关系运算、逻辑运算三大类。为了调用这以分为算术运算、关系运算、逻辑运算三大类。为了调用这以分为算术运算、关系运
23、算、逻辑运算三大类。为了调用这以分为算术运算、关系运算、逻辑运算三大类。为了调用这些标准函数对象，需要包含头文件些标准函数对象，需要包含头文件些标准函数对象，需要包含头文件些标准函数对象，需要包含头文件。1219941994年年年年7 7月，月，月，月，STLSTL正式成为标准正式成为标准正式成为标准正式成为标准C+C+库的一部分。库的一部分。库的一部分。库的一部分。STLSTL中的群体类是基于模板的，它既包含线性群体类，也包含非线性群体中的群体类是基于模板的，它既包含线性群体类，也包含非线性群体中的群体类是基于模板的，它既包含线性群体类，也包含非线性群体中的群体类是基于模板的，它既包含线性群
24、体类，也包含非线性群体类，其中主要有：类，其中主要有：类，其中主要有：类，其中主要有： vector(vector(向量向量向量向量) )list(list(链表链表链表链表) )stack(stack(栈栈栈栈) )queue(queue(队列队列队列队列) )dequedeque( (双端队列双端队列双端队列双端队列) )set(set(集合集合集合集合) )map(map(映射映射映射映射) )STLSTL的迭代子可以看成是指针的推广，迭代子也可以是普通的指针。的迭代子可以看成是指针的推广，迭代子也可以是普通的指针。的迭代子可以看成是指针的推广，迭代子也可以是普通的指针。的迭代子可以看成
25、是指针的推广，迭代子也可以是普通的指针。类型分类类型分类类型分类类型分类顺序访问：顺序访问：顺序访问：顺序访问：直接访问：直接访问：直接访问：直接访问：顺序迭代子使用顺序迭代子使用顺序迭代子使用顺序迭代子使用+、- -等进行移动，但只能顺序访等进行移动，但只能顺序访等进行移动，但只能顺序访等进行移动，但只能顺序访问群体类中的对象。问群体类中的对象。问群体类中的对象。问群体类中的对象。直接访问迭代子则可以直接访问群体类中的某个特直接访问迭代子则可以直接访问群体类中的某个特直接访问迭代子则可以直接访问群体类中的某个特直接访问迭代子则可以直接访问群体类中的某个特定对象。定对象。定对象。定对象。【 1
26、1.2.211.2.2标准模板类库标准模板类库标准模板类库标准模板类库STLSTL简介简介简介简介】STLSTL的算法是用函数模板实现的，可以实现对不同类型对象的通用操作。的算法是用函数模板实现的，可以实现对不同类型对象的通用操作。的算法是用函数模板实现的，可以实现对不同类型对象的通用操作。的算法是用函数模板实现的，可以实现对不同类型对象的通用操作。排序（排序（排序（排序（sortsort、mergemerge）查找（查找（查找（查找（findfind、searchsearch）比较（比较（比较（比较（equalequal）集合（集合（集合（集合（includesincludes、setuni
27、onsetunion、setdifferencesetdifference）计算（计算（计算（计算（accumulateaccumulate、partialsumpartialsum）统计（统计（统计（统计（maxmax、minmin）管理（管理（管理（管理（swapswap、fillfill、replacereplace、copycopy、uniqueunique、rotaterotate、reversereverse）堆操作（堆操作（堆操作（堆操作（makeheapmakeheap、pushheappushheap、popheappopheap、sortheapsortheap）算法与算法
28、与算法与算法与STLSTL群体类之间群体类之间群体类之间群体类之间是通过迭代子来进行沟通的，算法面向迭代子，迭是通过迭代子来进行沟通的，算法面向迭代子，迭是通过迭代子来进行沟通的，算法面向迭代子，迭是通过迭代子来进行沟通的，算法面向迭代子，迭代子则面向群体类代子则面向群体类代子则面向群体类代子则面向群体类, , 对于对于对于对于迭代子迭代子迭代子迭代子，可以将它理解为一个指针，通过它我们，可以将它理解为一个指针，通过它我们，可以将它理解为一个指针，通过它我们，可以将它理解为一个指针，通过它我们可以获得群体类内部的数据对象，然后算法对这个由迭代子获得的对象进可以获得群体类内部的数据对象，然后算法
29、对这个由迭代子获得的对象进可以获得群体类内部的数据对象，然后算法对这个由迭代子获得的对象进可以获得群体类内部的数据对象，然后算法对这个由迭代子获得的对象进行操作。行操作。行操作。行操作。STLSTL的主要算法有：的主要算法有：的主要算法有：的主要算法有： C+C+语言标准类库提供了语言标准类库提供了语言标准类库提供了语言标准类库提供了向量群体类向量群体类向量群体类向量群体类，向量既有象数组一样可以对群体类，向量既有象数组一样可以对群体类，向量既有象数组一样可以对群体类，向量既有象数组一样可以对群体类内部对象进行直接访问的特点，也有类似于链表可以对群体类内部对象进内部对象进行直接访问的特点，也有
30、类似于链表可以对群体类内部对象进内部对象进行直接访问的特点，也有类似于链表可以对群体类内部对象进内部对象进行直接访问的特点，也有类似于链表可以对群体类内部对象进行顺序访问的特点，同时向量具有动态特征，所以行顺序访问的特点，同时向量具有动态特征，所以行顺序访问的特点，同时向量具有动态特征，所以行顺序访问的特点，同时向量具有动态特征，所以C+C+语言中的向量群体语言中的向量群体语言中的向量群体语言中的向量群体类类类类具有数组和链表两者的优点具有数组和链表两者的优点具有数组和链表两者的优点具有数组和链表两者的优点。向量模板类中较为重要的成员函数有向量模板类中较为重要的成员函数有向量模板类中较为重要的
31、成员函数有向量模板类中较为重要的成员函数有beginbegin、endend、insertinsert、erase erase 、 operatoroperator等。等。等。等。iteratoriterator insert(iteratorinsert(iterator it, const T& x = T(); it, const T& x = T(); / /将将将将x x复制到复制到复制到复制到it it位置之前位置之前位置之前位置之前void void insert(iteratorinsert(iterator it, it, sizetypesizetype n, const
32、T& x); n, const T& x); / /将将将将n n个个个个x x复制到复制到复制到复制到it it位置之前位置之前位置之前位置之前void void insert(iteratorinsert(iterator it, it, constiteratorconstiterator first, first, constiteratorconstiterator last); last); / /将将将将firstfirst和和和和lastlast / /之间的对象复制到之间的对象复制到之间的对象复制到之间的对象复制到it it位置之前位置之前位置之前位置之前iteratorit
33、erator erase(iteratorerase(iterator it); it); / /移走移走移走移走it it位置的对象位置的对象位置的对象位置的对象iteratoriterator erase(iteratorerase(iterator first, first, iteratoriterator last); last); / /移走移走移走移走firstfirst到到到到lastlast之间的对象之间的对象之间的对象之间的对象用法如下：用法如下：用法如下：用法如下： beginbegin返回指向该向量的返回指向该向量的返回指向该向量的返回指向该向量的第一个对象的迭代子。第
34、一个对象的迭代子。第一个对象的迭代子。第一个对象的迭代子。endend返回一个指向向返回一个指向向返回一个指向向返回一个指向向量末尾值的迭代子。量末尾值的迭代子。量末尾值的迭代子。量末尾值的迭代子。insertinsert和和和和eraseerase是向量类的是向量类的是向量类的是向量类的插入和删除方法。插入和删除方法。插入和删除方法。插入和删除方法。【 11.3 11.3 向量向量向量向量】向量应用举例向量应用举例向量应用举例向量应用举例( (一一一一) )/EXAMPLE11_1.CPP/EXAMPLE11_1.CPP#include #include #include #include
35、#include #include #include #include #include #include using namespace std;using namespace std;void main ()void main () 说明一下说明一下说明一下说明一下copycopy和和和和accumulateaccumulate函数的用法：函数的用法：函数的用法：函数的用法：templateclass template OutItOutIt copy(InItcopy(InIt first, first, InItInIt last, last, OutItOutIt x); x); /
36、/该函该函该函该函 / /数将从数将从数将从数将从firstfirst到到到到lastlast之间的对象依次赋给位置之间的对象依次赋给位置之间的对象依次赋给位置之间的对象依次赋给位置x x的对象，的对象，的对象，的对象，/ /同时同时同时同时x+x+。在本例中是赋给标准输出流。在本例中是赋给标准输出流。在本例中是赋给标准输出流。在本例中是赋给标准输出流。templateclass template T , class T T accumulate(InItaccumulate(InIt first, first, InItInIt last, T last, T valval); ); / /
37、在在在在firstfirst / /和和和和lastlast之间依次取得对象值，每次该值与之间依次取得对象值，每次该值与之间依次取得对象值，每次该值与之间依次取得对象值，每次该值与valval的和替代原的和替代原的和替代原的和替代原valval值，返回值，返回值，返回值，返回valval。templateclass template T T accumulate(InItaccumulate(InIt first, first, InItInIt last, T last, T valval, , PredPred pr); pr); / /在在在在firstfirst和和和和lastlast
38、之间依次取得对象值，每次该值与之间依次取得对象值，每次该值与之间依次取得对象值，每次该值与之间依次取得对象值，每次该值与valval进行进行进行进行prpr运算后得到运算后得到运算后得到运算后得到的的的的 / /新值新值新值新值( (在例中用到在例中用到在例中用到在例中用到multiplies,multiplies,进行乘法运算进行乘法运算进行乘法运算进行乘法运算) )替代原替代原替代原替代原valval值值值值, ,返回返回返回返回valval。例例例例 11-111-111-111-1 vector vector nMyVector1, nMyVector1, / /整型向量整型向量整型向
39、量整型向量 nMyVector2;nMyVector2; / /该向量类型的迭代子该向量类型的迭代子该向量类型的迭代子该向量类型的迭代子 vector vector: :iteratoriterator nItBegin,nItEndnItBegin,nItEnd; ; / /该向量类型的输出流迭代子该向量类型的输出流迭代子该向量类型的输出流迭代子该向量类型的输出流迭代子 ostreamiteratorostreamiterator nOutput(coutnOutput(cout, );, ); / /对向量类型对象中的数据进行顺序赋值对向量类型对象中的数据进行顺序赋值对向量类型对象中的数据
40、进行顺序赋值对向量类型对象中的数据进行顺序赋值 for(intfor(int i=1;i=10;i+) i=1;i=10;i+) nMyVector1.pushback(i); nMyVector1.pushback(i); / /将该向量类型对象中的数据输出到标准输出流，显示出来。将该向量类型对象中的数据输出到标准输出流，显示出来。将该向量类型对象中的数据输出到标准输出流，显示出来。将该向量类型对象中的数据输出到标准输出流，显示出来。 copy(nMyVector1.begin(),nMyVector1.end(),nOutput);copy(nMyVector1.begin(),nMyVe
41、ctor1.end(),nOutput); coutcout endlendl; ; / /该向量类型的迭代子被赋值该向量类型的迭代子被赋值该向量类型的迭代子被赋值该向量类型的迭代子被赋值 nItBeginnItBegin =nMyVector1.begin(); =nMyVector1.begin(); nItEndnItEnd =nMyVector1.end(); =nMyVector1.end();（续）续）续）续） / /用用用用insertinsert函数实现两个向量类型对象成员数据的复制函数实现两个向量类型对象成员数据的复制函数实现两个向量类型对象成员数据的复制函数实现两个向量类型
42、对象成员数据的复制 nMyVector2.insert(nMyVector2.begin(),nMyVector1.begin(),nMyVector1.end();nMyVector2.insert(nMyVector2.begin(),nMyVector1.begin(),nMyVector1.end(); for(i=0;inMyVector2.size();i+) for(i=0;inMyVector2.size();i+) coutcoutnMyVector2nMyVector2i i ; ; coutcoutendlendl; ; / /用迭代子输出该向量类型对象的数据用迭代子输出
43、该向量类型对象的数据用迭代子输出该向量类型对象的数据用迭代子输出该向量类型对象的数据 while(nItBeginwhile(nItBegin!=!=nItEndnItEnd) ) coutcout*nItBeginnItBegin ; ; nItBeginnItBegin+;+; coutcout endlendl; ; / /用标准算法得到整型向量对象中所有数据的和用标准算法得到整型向量对象中所有数据的和用标准算法得到整型向量对象中所有数据的和用标准算法得到整型向量对象中所有数据的和 coutcout The sum of nMyVector1 The sum of nMyVector1i
44、 i is: is: accumulate(nMyVector1.begin(),nMyVector1.end(),0.0f) accumulate(nMyVector1.begin(),nMyVector1.end(),0.0f) endlendl; ; nItBeginnItBegin=nMyVector1.begin();=nMyVector1.begin(); nItEndnItEnd =nMyVector1.end(); =nMyVector1.end();（续）续）续）续） / /用一个已经存在的向量对象初始化另一个向量对象用一个已经存在的向量对象初始化另一个向量对象用一个已经存在
45、的向量对象初始化另一个向量对象用一个已经存在的向量对象初始化另一个向量对象 vector vector nMyVector3(nItBegin,nItEnd); nMyVector3(nItBegin,nItEnd); vector vector nMyVector4(nMyVector3); nMyVector4(nMyVector3); / /输出两个新的向量对象输出两个新的向量对象输出两个新的向量对象输出两个新的向量对象 copy(nMyVector3.begin(),nMyVector3.end(),nOutput);copy(nMyVector3.begin(),nMyVector3
46、.end(),nOutput); coutcout endlendl; ; copy(nMyVector4.begin(),nMyVector4.end(),nOutput); copy(nMyVector4.begin(),nMyVector4.end(),nOutput); coutcout endlendl; ; 1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10The sum of nMyVecto
47、r1The sum of nMyVector1i i is: 55 is: 551 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10（续）续）续）续）向量应用举例（二）向量应用举例（二）向量应用举例（二）向量应用举例（二）/EXAMPLE11_2.CPP/EXAMPLE11_2.CPP/ /程序开始程序开始程序开始程序开始# #pragmapragma warning (disable : 4786) warning (disable : 4786) / /防止一个编译警告的出现防止一个
48、编译警告的出现防止一个编译警告的出现防止一个编译警告的出现, ,过长的标识符过长的标识符过长的标识符过长的标识符( (例如变例如变例如变例如变 / /量名字长度超过量名字长度超过量名字长度超过量名字长度超过255255个个个个) )将在将在将在将在debug(debug(程序调试状态程序调试状态程序调试状态程序调试状态) )下被截断，以下同下被截断，以下同下被截断，以下同下被截断，以下同#include #include #include #include #include #include #include #include #include #include #include #inclu
49、de #include #include using namespace std; using namespace std; /*/*声明使用声明使用声明使用声明使用stdstd名称空间，这里名空间是名称空间，这里名空间是名称空间，这里名空间是名称空间，这里名空间是ANSI C+ANSI C+为解决为解决为解决为解决C/C+C/C+程序员经常遇到的命程序员经常遇到的命程序员经常遇到的命程序员经常遇到的命名冲突而采取的一个措施，名空间内的变量、函数与其他名空间内的同名变量或者名冲突而采取的一个措施，名空间内的变量、函数与其他名空间内的同名变量或者名冲突而采取的一个措施，名空间内的变量、函数与其他
50、名空间内的同名变量或者名冲突而采取的一个措施，名空间内的变量、函数与其他名空间内的同名变量或者函数无关，这样增加了程序员对变量和函数命名的灵活性。函数无关，这样增加了程序员对变量和函数命名的灵活性。函数无关，这样增加了程序员对变量和函数命名的灵活性。函数无关，这样增加了程序员对变量和函数命名的灵活性。stdstd是标准名空间。是标准名空间。是标准名空间。是标准名空间。* */ /class Point class Point /Point/Point类的声明及实现类的声明及实现类的声明及实现类的声明及实现 private: private: / /声明私有数据成员声明私有数据成员声明私有数据成
51、员声明私有数据成员例例例例 11-211-211-211-2 intint x; x; intint y; y;public: public: / /声明对外接口声明对外接口声明对外接口声明对外接口 Point(intPoint(int xx=0,int xx=0,int yyyy=0) =0) / /带默认形参值的构造函数带默认形参值的构造函数带默认形参值的构造函数带默认形参值的构造函数 x= x=xx;yxx;y= =yyyy; ; void display() void display() / /显示函数显示函数显示函数显示函数 coutcoutPoint(x,y) ;Point(x,y
52、) ; intint getxgetx() const return x;() const return x;intint getygety() const return y;() const return y;boolbool operator =(const Point &point2) const;/ operator =(const Point &point2) const;/用户自定义类型必须重载用户自定义类型必须重载用户自定义类型必须重载用户自定义类型必须重载=和和和和/ / =、=。boolbool operator (const Point &point2) const; op
53、erator (const Point &point2) const; ; ;boolbool Point:operator =(const Point &point2) const Point:operator =(const Point &point2) const if(x=point2.getx()&(y=point2.gety() if(x=point2.getx()&(y=point2.gety()（续）（续）（续）（续） return true ;return true ; else return false ; else return false ; boolbool Poin
54、t:operator (const Point &point2) const Point:operator (const Point &point2) const if(getxif(getx()point2.getx()&(gety()point2.gety()()point2.getx()&(gety()point2.gety() return true ; return true ; else return false ; else return false ; void main ()void main () vector vector nMyVector1, nMyVector1,
55、/ /整型向量整型向量整型向量整型向量nMyVector2;nMyVector2; vector dblMyVector1, vector dblMyVector1, / /双精度型向量双精度型向量双精度型向量双精度型向量dblMyVector2;dblMyVector2; vector cMyVector1, vector cMyVector1, / /字符型向量字符型向量字符型向量字符型向量cMyVector2;cMyVector2; vector strMyVector1, vector strMyVector1, / /字符串型向量字符串型向量字符串型向量字符串型向量strMyVect
56、or2;strMyVector2; vector ptMyVector1, vector ptMyVector1, /Point/Point型向量型向量型向量型向量（续）（续）（续）（续）ptMyVector2;ptMyVector2; / /针对不同向量类型的迭代子针对不同向量类型的迭代子针对不同向量类型的迭代子针对不同向量类型的迭代子 vector vector: :iteratoriterator nItBegin,nItEndnItBegin,nItEnd; ; vector: vector:iteratoriterator dblItBegin,dblItEnddblItBegin,
57、dblItEnd; ; vector: vector:iteratoriterator cItBegin,cItEndcItBegin,cItEnd; ; vector: vector:iteratoriterator strItBegin,strItEndstrItBegin,strItEnd; ; vector: vector:iteratoriterator ptItBegin,ptItEndptItBegin,ptItEnd; ; / /针对不同向量类型的输出流迭代子针对不同向量类型的输出流迭代子针对不同向量类型的输出流迭代子针对不同向量类型的输出流迭代子 ostreamiterato
58、rostreamiterator nOutput(coutnOutput(cout, );, ); ostreamiteratorostreamiterator dblOutput(coutdblOutput(cout, );, ); ostreamiteratorostreamiterator cOutput(coutcOutput(cout, );, ); ostreamiteratorostreamiterator strOutput(coutstrOutput(cout, );, ); / /向各种向量类型对象中写入数据向各种向量类型对象中写入数据向各种向量类型对象中写入数据向各种向量
59、类型对象中写入数据 for(intfor(int i=1;i=10;i+) i=1;i=10;i+) nMyVector1.pushback(i); nMyVector1.pushback(i); dblMyVector1.pushback(i/10.0); dblMyVector1.pushback(i/10.0); cMyVector1.pushback(A+i); cMyVector1.pushback(A+i);（续）（续）（续）（续） Point *point=new Point(i,i);Point *point=new Point(i,i); ptMyVector1.pushba
60、ck(*point); ptMyVector1.pushback(*point); strMyVector1.pushback(I ); strMyVector1.pushback(I ); strMyVector1.pushback(Like ); strMyVector1.pushback(Like ); strMyVector1.pushback(C+!); strMyVector1.pushback(C+!); / /将不同向量类型对象中的数据输出到标准输出流，显示出来。将不同向量类型对象中的数据输出到标准输出流，显示出来。将不同向量类型对象中的数据输出到标准输出流，显示出来。将不同向
61、量类型对象中的数据输出到标准输出流，显示出来。 copy(nMyVector1.begin(),nMyVector1.end(),nOutput);copy(nMyVector1.begin(),nMyVector1.end(),nOutput); coutcout endlendl; ; copy(dblMyVector1.begin(),dblMyVector1.end(),dblOutput); copy(dblMyVector1.begin(),dblMyVector1.end(),dblOutput); coutcout endlendl; ; copy(cMyVector1.beg
62、in(),cMyVector1.end(),cOutput); copy(cMyVector1.begin(),cMyVector1.end(),cOutput); coutcout endlendl; ; copy(strMyVector1.begin(),strMyVector1.end(),strOutput); copy(strMyVector1.begin(),strMyVector1.end(),strOutput); coutcout endlendl; ; / /各个向量类型的迭代子被赋值各个向量类型的迭代子被赋值各个向量类型的迭代子被赋值各个向量类型的迭代子被赋值 nItBe
63、ginnItBegin =nMyVector1.begin(); =nMyVector1.begin(); dblItBegindblItBegin=dblMyVector1.begin();=dblMyVector1.begin();（续）（续）（续）（续） cItBegincItBegin =cMyVector1.begin(); =cMyVector1.begin(); strItBeginstrItBegin=strMyVector1.begin();=strMyVector1.begin(); ptItBeginptItBegin =ptMyVector1.begin(); =ptM
64、yVector1.begin(); nItEndnItEnd =nMyVector1.end(); =nMyVector1.end(); dblItEnddblItEnd=dblMyVector1.end();=dblMyVector1.end(); cItEndcItEnd =cMyVector1.end(); =cMyVector1.end(); strItEndstrItEnd=strMyVector1.end();=strMyVector1.end(); ptItEndptItEnd =ptMyVector1.end(); =ptMyVector1.end(); / /用用用用inse
65、rtinsert函数实现两个向量类型对象成员数据的复制函数实现两个向量类型对象成员数据的复制函数实现两个向量类型对象成员数据的复制函数实现两个向量类型对象成员数据的复制 nMyVector2.insert(nMyVector2.begin(),nMyVector1.begin(),nMyVector1.end();nMyVector2.insert(nMyVector2.begin(),nMyVector1.begin(),nMyVector1.end(); for(i=0;inMyVector2.size();i+) for(i=0;inMyVector2.size();i+) coutco
66、utnMyVector2nMyVector2i i ; ; coutcoutendlendl; ; dblMyVector2.insert(dblMyVector2.begin(),dblMyVector1.begin(),dblMyVector1 dblMyVector2.insert(dblMyVector2.begin(),dblMyVector1.begin(),dblMyVector1.end();.end(); for(i=0;idblMyVector2.size();i+) for(i=0;idblMyVector2.size();i+) （续）（续）（续）（续） coutcou
67、tdblMyVector2dblMyVector2i i ; ; coutcoutendlendl; ; cMyVector2.insert(cMyVector2.begin(),cMyVector1.begin(),cMyVector1.end(); cMyVector2.insert(cMyVector2.begin(),cMyVector1.begin(),cMyVector1.end(); for(i=0;icMyVector2.size();i+) for(i=0;icMyVector2.size();i+) coutcoutcMyVector2cMyVector2i i ; ; c
68、outcoutendlendl; ; strMyVector2.insert(strMyVector2.begin(),strMyVector1.begin(),strMyVector1 strMyVector2.insert(strMyVector2.begin(),strMyVector1.begin(),strMyVector1.end();.end(); for(i=0;istrMyVector2.size();i+) for(i=0;istrMyVector2.size();i+) coutcoutstrMyVector2strMyVector2i i ; ; coutcoutend
69、lendl; ; ptMyVector2.insert(ptMyVector2.begin(),ptMyVector1.begin(),ptMyVector1.end ptMyVector2.insert(ptMyVector2.begin(),ptMyVector1.begin(),ptMyVector1.end();(); for(i=0;iptMyVector2.size();i+) for(i=0;iptMyVector2.size();i+) （续）（续）（续）（续） intint static count=0; static count=0; if(count=5) if(coun
70、t=5) count=0; count=0; coutcoutendlendl; ; ptMyVector2 ptMyVector2i i.display();.display(); count+; count+; coutcoutendlendl; ; / /用迭代子输出不同向量类型对象的数据用迭代子输出不同向量类型对象的数据用迭代子输出不同向量类型对象的数据用迭代子输出不同向量类型对象的数据 while(nItBeginwhile(nItBegin!=!=nItEndnItEnd) ) coutcout*nItBeginnItBegin ; ; nItBeginnItBegin+;+; c
71、outcout endlendl; ; while(dblItBeginwhile(dblItBegin!=!=dblItEnddblItEnd) ) （续）（续）（续）（续） coutcout*dblItBegindblItBegin ; ; dblItBegindblItBegin+=2;+=2; coutcout endlendl; ; while(cItEndwhile(cItEnd!=!=cItBegincItBegin) ) coutcout*(-*(-cItEndcItEnd) ;) ; coutcout endlendl; ; while(strItBeginwhile(str
72、ItBegin!=!=strItEndstrItEnd) ) coutcout*strItBeginstrItBegin ; ; strItBeginstrItBegin+;+; coutcout endlendl; ; while(ptItBeginwhile(ptItBegin!=!=ptItEndptItEnd) ) intint static count=0; static count=0; if(count=5) if(count=5)（续）（续）（续）（续） count=0; count=0; coutcoutdisplay();-display(); ptItBeginptItB
73、egin+;+; count+; count+; coutcout endlendl; ; / /用标准算法得到整型向量对象中所有数据的和用标准算法得到整型向量对象中所有数据的和用标准算法得到整型向量对象中所有数据的和用标准算法得到整型向量对象中所有数据的和 coutcout The sum of nMyVector1 The sum of nMyVector1i i is: is: accumulate (nMyVector1.begin(),nMyVector1.end(),0.0f) accumulate (nMyVector1.begin(),nMyVector1.end(),0.0f
74、) endlendl; ; / /用标准算法得到双精度型向量对象中所有数据的积用标准算法得到双精度型向量对象中所有数据的积用标准算法得到双精度型向量对象中所有数据的积用标准算法得到双精度型向量对象中所有数据的积 coutcout The multiplies of dblMyVector1 The multiplies of dblMyVector1i i is:is: accumulate(dblMyVector1.begin(),dblMyVector1.end( accumulate(dblMyVector1.begin(),dblMyVector1.end(),1.0f,multipl
75、ies(),1.0f,multiplies() endlendl; ;（续）（续）（续）（续） / /从字符型向量对象中弹出数据从字符型向量对象中弹出数据从字符型向量对象中弹出数据从字符型向量对象中弹出数据 for(i=0;i5;i+)for(i=0;i5;i+) cItEndcItEnd=cMyVector1.end();=cMyVector1.end(); coutcoutThe Element will be pop is: *(-The Element will be pop is: *(-cItEndcItEnd)endlendl; ; cMyVector1.popback(); c
76、MyVector1.popback(); cItEndcItEnd=cMyVector1.end();=cMyVector1.end(); cItBegincItBegin=cMyVector1.begin();=cMyVector1.begin(); / /输出弹出数据后的字符型向量对象的数据输出弹出数据后的字符型向量对象的数据输出弹出数据后的字符型向量对象的数据输出弹出数据后的字符型向量对象的数据 while(cItBeginwhile(cItBegin!=!=cItEndcItEnd) ) coutcout*cItBegincItBegin ; ; cItBegincItBegin+;+
77、; coutcout endlendl; ; nItBeginnItBegin=nMyVector1.begin();=nMyVector1.begin(); nItEndnItEnd =nMyVector1.end(); =nMyVector1.end();（续）（续）（续）（续） / /用一个已经存在的向量对象初始化另一个向量对象用一个已经存在的向量对象初始化另一个向量对象用一个已经存在的向量对象初始化另一个向量对象用一个已经存在的向量对象初始化另一个向量对象 vector vector nMyVector3(nItBegin,nItEnd); nMyVector3(nItBegin,nI
78、tEnd); vector vector nMyVector4(nMyVector3); nMyVector4(nMyVector3); / /输出两个新的向量对象输出两个新的向量对象输出两个新的向量对象输出两个新的向量对象 copy(nMyVector3.begin(),nMyVector3.end(),nOutput);copy(nMyVector3.begin(),nMyVector3.end(),nOutput); coutcout endlendl; ; copy(nMyVector4.begin(),nMyVector4.end(),nOutput); copy(nMyVector
79、4.begin(),nMyVector4.end(),nOutput); coutcout endlendl; ; / /源程序结束源程序结束源程序结束源程序结束（续）（续）（续）（续）1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 100.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KB C D E F G H I J KI Like C+!I Like C+!1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8
80、 9 100.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KB C D E F G H I J KI Like C+!I Like C+!Point(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10
81、)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)The sum of nMyVector1The sum of nMyVector1i i is: 55is: 55The multiplies of The multiplies of dblMyVectordblMyVectori i is: 0.00036288is: 0.00036288The Element will be pop is: KThe Element will be pop is: KThe Element will be pop is: JThe Elem
82、ent will be pop is: JThe Element will be pop is: IThe Element will be pop is: IThe Element will be pop is: HThe Element will be pop is: HThe Element will be pop is: GThe Element will be pop is: GB C D E FB C D E F1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10（续）（续）（
83、续）（续）链表类中比较重要的成员函数与向量基本相同，但注意链表类不包含链表类中比较重要的成员函数与向量基本相同，但注意链表类不包含链表类中比较重要的成员函数与向量基本相同，但注意链表类不包含链表类中比较重要的成员函数与向量基本相同，但注意链表类不包含运算符重载，也没有运算符重载，也没有运算符重载，也没有运算符重载，也没有+=+=或或或或-=-=重载，这一点与向量不同。重载，这一点与向量不同。重载，这一点与向量不同。重载，这一点与向量不同。例例例例 11-311-311-311-3链表类应用举例链表类应用举例链表类应用举例链表类应用举例/EXAMPLE11_3.CPP/EXAMPLE11_3.C
84、PP/ /源程序开始源程序开始源程序开始源程序开始# #pragmapragma warning (disable : 4786) warning (disable : 4786) / /防止一个编译警告的出现防止一个编译警告的出现防止一个编译警告的出现防止一个编译警告的出现#include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; using namespace
85、 std; / /声明使用声明使用声明使用声明使用stdstd名称空间名称空间名称空间名称空间（续）（续）（续）（续）【 11.4 11.4 链表类的使用链表类的使用链表类的使用链表类的使用】class Point class Point /Point/Point类的声明及实现类的声明及实现类的声明及实现类的声明及实现 private: private: / /声明私有数据成员声明私有数据成员声明私有数据成员声明私有数据成员 intint x; x; intint y; y;public: public: / /声明对外接口声明对外接口声明对外接口声明对外接口 Point(intPoint(i
86、nt xx=0,int xx=0,int yyyy=0) =0) / /带默认形参值的构造函数带默认形参值的构造函数带默认形参值的构造函数带默认形参值的构造函数 x= x=xx;yxx;y= =yyyy; ; void display() void display() / /显示函数显示函数显示函数显示函数 coutcoutPoint(x,y) ;Point(x,y) ; intint getxgetx() const return x;() const return x; intint getygety() const return y;() const return y; boolbool
87、 operator =(const Point &point2) const; operator =(const Point &point2) const; boolbool operator (const Point &point2) const; operator (const Point &point2) const; ;链表类应用举例链表类应用举例链表类应用举例链表类应用举例例例例例 11-311-311-311-3boolbool Point:operator =(const Point &point2) const Point:operator =(const Point &poi
88、nt2) const if(x= if(x=point2.getx()&(point2.getx()&(y=point2.gety()y=point2.gety() return true ; return true ; else return false ; else return false ; boolbool Point:operator (const Point &point2) const Point:operator (const Point &point2) const if(getxif(getx()point2.getx()&(gety()point2.gety()()po
89、int2.getx()&(gety()point2.gety() return true ; return true ; else return false ; else return false ; void main ()void main () list list nMyList1, nMyList1, / /整型整型整型整型listlist MyList2; MyList2; list dblMyList1, list dblMyList1, / /双精度型双精度型双精度型双精度型listlist dblMyList2; dblMyList2;（续）续）续）续） list cMyLis
90、t1, list cMyList1, / /字符型字符型字符型字符型listlistcMyList2;cMyList2; list strMyList1, list strMyList1, / /字符串型字符串型字符串型字符串型listliststrMyList2;strMyList2; list ptMyList1, list ptMyList1, /Point/Point型型型型listlistptMyList2ptMyList2 / /针对不同针对不同针对不同针对不同listlist类型的迭代子类型的迭代子类型的迭代子类型的迭代子 list list: :iteratoriterator
91、 nItBegin1,nItEnd1, nItBegin1,nItEnd1, nItBegin2,nItEnd2; nItBegin2,nItEnd2; list: list:iteratoriterator dblItBegin1,dblItEnd1, dblItBegin1,dblItEnd1, dblItBegin2,dblItEnd2; dblItBegin2,dblItEnd2; list: list:iteratoriterator cItBegin1,cItEnd1, cItBegin1,cItEnd1, cItBegin2,cItEnd2; cItBegin2,cItEnd2;
92、 list: list:iteratoriterator strItBegin1,strItEnd1, strItBegin1,strItEnd1, strItBegin2,strItEnd2; strItBegin2,strItEnd2; list: list:iteratoriterator ptItBegin1,ptItEnd1, ptItBegin1,ptItEnd1, ptItBegin2,ptItEnd2; ptItBegin2,ptItEnd2;/ /针对不同针对不同针对不同针对不同listlist类型的输出流迭代子类型的输出流迭代子类型的输出流迭代子类型的输出流迭代子ostre
93、amiteratorostreamiterator nOutput(coutnOutput(cout, );, );（续）续）续）续）ostreamiteratorostreamiterator dblOutput(coutdblOutput(cout, );, );ostreamiteratorostreamiterator cOutput(coutcOutput(cout, );, );ostreamiteratorostreamiterator strOutput(coutstrOutput(cout, );, );/ /对对对对listlist类型对象中的数据赋值类型对象中的数据赋值类
94、型对象中的数据赋值类型对象中的数据赋值for(intfor(int i=1;i=10;i+) i=1;i=10;i+) nMyList1.pushback(i); nMyList1.pushback(i); dblMyList1.pushback(i/10.0); dblMyList1.pushback(i/10.0); cMyList1.pushback(A+i); cMyList1.pushback(A+i); Point *point=new Point(i,i); Point *point=new Point(i,i); ptMyList1.pushback(*point); ptMy
95、List1.pushback(*point); strMyList1.pushback(I );strMyList1.pushback(I );strMyList1.pushback(Like );strMyList1.pushback(Like );strMyList1.pushback(C+!);strMyList1.pushback(C+!);/ /将不同将不同将不同将不同listlist类型对象中的数据输出到标准输出流，显示出来。类型对象中的数据输出到标准输出流，显示出来。类型对象中的数据输出到标准输出流，显示出来。类型对象中的数据输出到标准输出流，显示出来。copy(nMyList1
96、.begin(),nMyList1.end(),nOutput);copy(nMyList1.begin(),nMyList1.end(),nOutput);coutcout endlendl; ;（续）续）续）续）copy(dblMyList1.begin(),dblMyList1.end(),dblOutput);copy(dblMyList1.begin(),dblMyList1.end(),dblOutput);coutcout endlendl; ;copy(cMyList1.begin(),cMyList1.end(),cOutput);copy(cMyList1.begin(),
97、cMyList1.end(),cOutput);coutcout endlendl; ;copy(strMyList1.begin(),strMyList1.end(),strOutput);copy(strMyList1.begin(),strMyList1.end(),strOutput);coutcout endlendl; ;/ /各个各个各个各个listlist类型的迭代子被赋值类型的迭代子被赋值类型的迭代子被赋值类型的迭代子被赋值nItBegin1 =nMyList1.begin();nItBegin1 =nMyList1.begin();dblItBegin1=dblMyList
98、1.begin();dblItBegin1=dblMyList1.begin();cItBegin1 =cMyList1.begin();cItBegin1 =cMyList1.begin();strItBegin1=strMyList1.begin();strItBegin1=strMyList1.begin();ptItBegin1 =ptMyList1.begin();ptItBegin1 =ptMyList1.begin();nItEnd1 =nMyList1.end();nItEnd1 =nMyList1.end();dblItEnd1=dblMyList1.end();dblItE
99、nd1=dblMyList1.end();cItEnd1 =cMyList1.end();cItEnd1 =cMyList1.end();strItEnd1=strMyList1.end();strItEnd1=strMyList1.end();ptItEnd1 =ptMyList1.end();ptItEnd1 =ptMyList1.end();/ /用用用用insertinsert函数实现两个函数实现两个函数实现两个函数实现两个listlist类型对象成员数据的复制类型对象成员数据的复制类型对象成员数据的复制类型对象成员数据的复制nMyList2.insert(nMyList2.begin
100、(),nMyList1.begin(),nMyList1.end();nMyList2.insert(nMyList2.begin(),nMyList1.begin(),nMyList1.end();dblMyList2.insert(dblMyList2.begin(),dblMyList1.begin(),dblMyList1.end();dblMyList2.insert(dblMyList2.begin(),dblMyList1.begin(),dblMyList1.end();（续）续）续）续）cMyList2.insert(cMyList2.begin(),cMyList1.beg
101、in(),cMyList1.end();cMyList2.insert(cMyList2.begin(),cMyList1.begin(),cMyList1.end();strMyList2.insert(strMyList2.begin(),strMyList1.begin(),strMyList1.end(); strMyList2.insert(strMyList2.begin(),strMyList1.begin(),strMyList1.end(); ptMyList2.insert(ptMyList2.begin(),ptMyList1.begin(),ptMyList1.end(
102、); ptMyList2.insert(ptMyList2.begin(),ptMyList1.begin(),ptMyList1.end(); / /各个各个各个各个listlist类型的迭代子被赋值类型的迭代子被赋值类型的迭代子被赋值类型的迭代子被赋值nItBegin2 =nMyList2.begin();nItBegin2 =nMyList2.begin();dblItBegin2=dblMyList2.begin();dblItBegin2=dblMyList2.begin();cItBegin2 =cMyList2.begin();cItBegin2 =cMyList2.begin(
103、);strItBegin2=strMyList2.begin();strItBegin2=strMyList2.begin();ptItBegin2 =ptMyList2.begin();ptItBegin2 =ptMyList2.begin();nItEnd2 =nMyList2.end();nItEnd2 =nMyList2.end();dblItEnd2=dblMyList2.end();dblItEnd2=dblMyList2.end();cItEnd2 =cMyList2.end();cItEnd2 =cMyList2.end();strItEnd2=strMyList2.end()
104、;strItEnd2=strMyList2.end();ptItEnd2 =ptMyList2.end();ptItEnd2 =ptMyList2.end();/ /用迭代子输出不同用迭代子输出不同用迭代子输出不同用迭代子输出不同listlist类型对象的数据类型对象的数据类型对象的数据类型对象的数据, ,对于对于对于对于listlist类型不能对迭代子使用类型不能对迭代子使用类型不能对迭代子使用类型不能对迭代子使用+=/-=+=/-=等等等等/ /运算符也不能使用进行直接存取运算符也不能使用进行直接存取运算符也不能使用进行直接存取运算符也不能使用进行直接存取（续）续）续）续）while(nI
105、tBegin1!=nItEnd1) while(nItBegin1!=nItEnd1) / /输出输出输出输出nMyList1nMyList1 coutcout*nItBegin1 ;*nItBegin1 ; nItBegin1+; nItBegin1+; coutcout endlendl; ;while(dblItBegin1!=dblItEnd1) while(dblItBegin1!=dblItEnd1) / /输出输出输出输出dblMyList1dblMyList1 coutcout*dblItBegin1 ;*dblItBegin1 ;dblItBegin1+;dblItBegin
106、1+; coutcout endlendl; ;while(cItEnd1!=cItBegin1) while(cItEnd1!=cItBegin1) / /输出输出输出输出cMyList1cMyList1 coutcout*(-cItEnd1) ;*(-cItEnd1) ; coutcout endlendl; ;while(strItBegin1!=strItEnd1) while(strItBegin1!=strItEnd1) / /输出输出输出输出strMyList1strMyList1（续）续）续）续） coutcout*strItBegin1 ;*strItBegin1 ;strI
107、tBegin1+;strItBegin1+; coutcout endlendl; ;while(ptItBegin1!=ptItEnd1) while(ptItBegin1!=ptItEnd1) / /输出输出输出输出ptMyList1ptMyList1 intint static count=0; static count=0;if(count=5)if(count=5) count=0;count=0;coutcoutdisplay();ptItBegin1-display();ptItBegin1+;ptItBegin1+;count+;count+; coutcout endlend
108、l; ;/ /分别输出用分别输出用分别输出用分别输出用insertinsert函数得到的新对象函数得到的新对象函数得到的新对象函数得到的新对象while(nItBegin2!=nItEnd2) while(nItBegin2!=nItEnd2) / /输出输出输出输出nMyList2nMyList2（续）续）续）续） coutcout*nItBegin2 ;*nItBegin2 ;nItBegin2+;nItBegin2+; coutcout endlendl; ;while(dblItBegin2!=dblItEnd2) while(dblItBegin2!=dblItEnd2) / /输出
109、输出输出输出dblMyLIst2dblMyLIst2 coutcout*dblItBegin2 ;*dblItBegin2 ;dblItBegin2+; dblItBegin2+; coutcout endlendl; ;while(cItEnd2!=cItBegin2) while(cItEnd2!=cItBegin2) / /输出输出输出输出cMyList2cMyList2 0 0 coutcout*(-cItEnd2) ;*(-cItEnd2) ; coutcout endlendl; ;while(strItBegin2!=strItEnd2) while(strItBegin2!=s
110、trItEnd2) / /输出输出输出输出strMyList2strMyList2 （续）续）续）续）coutcout*strItBegin2 ;*strItBegin2 ;strItBegin2+;strItBegin2+; coutcout endlendl; ;while(ptItBegin2!=ptItEnd2) while(ptItBegin2!=ptItEnd2) / /输出输出输出输出ptMyList2ptMyList2 intint static count=0; static count=0;if(count=5)if(count=5) count=0; count=0; c
111、outcoutdisplay();ptItBegin2-display();ptItBegin2+;ptItBegin2+;count+;count+; coutcout endlendl; ;/ /从字符型从字符型从字符型从字符型listlist对象中弹出数据对象中弹出数据对象中弹出数据对象中弹出数据for(i=0;i5;i+)for(i=0;i5;i+) （续）续）续）续）cItEnd1=cMyList1.end();cItEnd1=cMyList1.end();coutcoutThe Element will be pop is: *(-cItEnd1)The Element will
112、be pop is: *(-cItEnd1)endlendl; ; cMyList1.popback();cMyList1.popback(); cItEnd1=cMyList1.end();cItEnd1=cMyList1.end();cItBegin1=cMyList1.begin();cItBegin1=cMyList1.begin();/ /输出弹出数据后的字符型输出弹出数据后的字符型输出弹出数据后的字符型输出弹出数据后的字符型listlist对象的数据对象的数据对象的数据对象的数据while(cItBegin1!=cItEnd1)while(cItBegin1!=cItEnd1) c
113、outcout*cItBegin1 ;*cItBegin1 ;cItBegin1+;cItBegin1+; coutcout endlendl; ;nItBegin1=nMyList1.begin();nItBegin1=nMyList1.begin();nItEnd1 =nMyList1.end();nItEnd1 =nMyList1.end();/ /用一个已经存在的用一个已经存在的用一个已经存在的用一个已经存在的listlist对象初始化另一个对象初始化另一个对象初始化另一个对象初始化另一个listlist对象对象对象对象list list nMyList3(nItBegin1,nItE
114、nd1); nMyList3(nItBegin1,nItEnd1);list list nMyList4(nMyList3); nMyList4(nMyList3);（续）续）续）续）/ /输出两个新的输出两个新的输出两个新的输出两个新的listlist对象对象对象对象copy(nMyList3.begin(),nMyList3.end(),nOutput);copy(nMyList3.begin(),nMyList3.end(),nOutput);coutcout endlendl; ;copy(nMyList4.begin(),nMyList4.end(),nOutput);copy(nM
115、yList4.begin(),nMyList4.end(),nOutput);coutcout endlendl; ; / /源程序结束源程序结束源程序结束源程序结束1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 100.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KB C D E F G H I J KI Like C+!I Like C+!1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 100.1 0
116、.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KB C D E F G H I J KI Like C+!I Like C+!Point(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)Point(6,6
117、) Point(7,7) Point(8,8) Point(9,9) Point(10,10)（续）续）续）续）1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 100.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KB C D E F G H I J KI Like C+!I Like C+!Point(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(1,1) Point(2
118、,2) Point(3,3) Point(4,4) Point(5,5)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)The Element will be pop is: KThe Element will be pop is: KThe Element will be pop is: JThe Element will be pop is: JThe Element will be pop is: IThe Ele
119、ment will be pop is: IThe Element will be pop is: HThe Element will be pop is: HThe Element will be pop is: GThe Element will be pop is: GB C D E FB C D E F1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10（续）续）续）续）双端队列，支持对数据的直接访问和顺序访问。双端队列的基本操作双端队列，支持对数据的直接访问和顺序访问。双端队列
120、的基本操作双端队列，支持对数据的直接访问和顺序访问。双端队列的基本操作双端队列，支持对数据的直接访问和顺序访问。双端队列的基本操作一般一般一般一般用在对象序列的开头或结尾频繁插入或者删除的情况。用在对象序列的开头或结尾频繁插入或者删除的情况。用在对象序列的开头或结尾频繁插入或者删除的情况。用在对象序列的开头或结尾频繁插入或者删除的情况。/EXAMPLE11_4.CPP/EXAMPLE11_4.CPP/ /源程序开始源程序开始源程序开始源程序开始# #pragmapragma warning (disable : 4786) warning (disable : 4786) / /防止一个编译警
121、告的出现防止一个编译警告的出现防止一个编译警告的出现防止一个编译警告的出现#include #include #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; using namespace std; / /声明使用声明使用声明使用声明使用stdstd名称空间名称空间名称空间名称空间例例例例 11-411-411-411-4双端队列应用举例双端队列应用举例双端队列应用举例双端队列应用举例【
122、 11.5 11.5 双端队列双端队列双端队列双端队列】例例例例 11-411-411-411-4class Point class Point / /类类类类PointPoint的声明及实现的声明及实现的声明及实现的声明及实现 private: private: / /声明私有数据成员声明私有数据成员声明私有数据成员声明私有数据成员 intint x; x; intint y; y;public: public: / /声明对外接口声明对外接口声明对外接口声明对外接口 Point(intPoint(int xx=0,int xx=0,int yyyy=0) =0) / /带默认形参值的构造函
123、数带默认形参值的构造函数带默认形参值的构造函数带默认形参值的构造函数 x= x=xx;yxx;y= =yyyy; ; void display() void display() / /显示函数显示函数显示函数显示函数 coutcoutPoint(x,y) ;Point(x,y) ; intint getxgetx() const return x;() const return x;intint getygety() const return y;() const return y;boolbool operator =(const Point &point2) const; operator
124、 =(const Point &point2) const;boolbool operator (const Point &point2) const; operator (const Point &point2) const; ;双端队列应用举例双端队列应用举例双端队列应用举例双端队列应用举例boolbool Point:operator =(const Point &point2) const Point:operator =(const Point &point2) const if(x=point2.getx()&(y=point2.gety() if(x=point2.getx()&
125、(y=point2.gety() return true ; return true ; else return false ; else return false ; boolbool Point:operator (const Point &point2) const Point:operator (const Point &point2) const if(getxif(getx()point2.getx()&(gety()point2.gety()()point2.getx()&(gety()point2.gety() return true ; return true ; else
126、return false ; else return false ; void main ()void main () dequedeque nMyDeque1, nMyDeque1, / /整型双端队列整型双端队列整型双端队列整型双端队列nMyDeque2;nMyDeque2; dequedeque dblMyDeque1, dblMyDeque1, / /双精度型双端队列双精度型双端队列双精度型双端队列双精度型双端队列dblMyDeque2;dblMyDeque2; dequedeque cMyDeque1, cMyDeque1, / /字符型双端队列字符型双端队列字符型双端队列字符型双端
127、队列cMyDeque2;cMyDeque2;（续）续）续）续） dequedeque strMyDeque1, strMyDeque1, / /字符串型双端队列字符串型双端队列字符串型双端队列字符串型双端队列strMyDeque2;strMyDeque2; dequedeque ptMyDeque1, ptMyDeque1, /Point/Point型双端队列型双端队列型双端队列型双端队列ptMyDeque2;ptMyDeque2; / /针对不同双端队列类型的迭代子针对不同双端队列类型的迭代子针对不同双端队列类型的迭代子针对不同双端队列类型的迭代子 dequedeque : :iterato
128、riterator nItBegin,nItEndnItBegin,nItEnd; ; dequedeque:iteratoriterator dblItBegin,dblItEnddblItBegin,dblItEnd; ; dequedeque:iteratoriterator cItBegin,cItEndcItBegin,cItEnd; ; dequedeque:iteratoriterator strItBegin,strItEndstrItBegin,strItEnd; ; dequedeque:iteratoriterator ptItBegin,ptItEndptItBegin
129、,ptItEnd; ; / /针对不同双端队列类型的输出流迭代子针对不同双端队列类型的输出流迭代子针对不同双端队列类型的输出流迭代子针对不同双端队列类型的输出流迭代子 ostreamiteratorostreamiterator nOutput(coutnOutput(cout, );, ); ostreamiteratorostreamiterator dblOutput(coutdblOutput(cout, );, ); ostreamiteratorostreamiterator cOutput(coutcOutput(cout, );, ); ostreamiteratorostre
130、amiterator strOutput(coutstrOutput(cout, );, ); / /得到各种双端队列类型对象中的数据得到各种双端队列类型对象中的数据得到各种双端队列类型对象中的数据得到各种双端队列类型对象中的数据 for(intfor(int i=1;i=10;i+) i=1;i=10;i+) nMyDeque1.pushback(i); nMyDeque1.pushback(i);（续）续）续）续） dblMyDeque1.pushfront(i/10.0);dblMyDeque1.pushfront(i/10.0); cMyDeque1.pushback(A+i); cM
131、yDeque1.pushback(A+i); Point *point=new Point(i,i); Point *point=new Point(i,i); ptMyDeque1.pushback(*point); ptMyDeque1.pushback(*point); strMyDeque1.pushback(I ); strMyDeque1.pushback(I ); strMyDeque1.pushback(Like ); strMyDeque1.pushback(Like ); strMyDeque1.pushback(C+!); strMyDeque1.pushback(C+!
132、); / /将不同双端队列类型对象中的数据输出到标准输出流，显示出来将不同双端队列类型对象中的数据输出到标准输出流，显示出来将不同双端队列类型对象中的数据输出到标准输出流，显示出来将不同双端队列类型对象中的数据输出到标准输出流，显示出来 copy(nMyDeque1.begin(),nMyDeque1.end(),nOutput);copy(nMyDeque1.begin(),nMyDeque1.end(),nOutput); coutcout endlendl; ; copy(dblMyDeque1.begin(),dblMyDeque1.end(),dblOutput); copy(dbl
133、MyDeque1.begin(),dblMyDeque1.end(),dblOutput); coutcout endlendl; ; copy(cMyDeque1.begin(),cMyDeque1.end(),cOutput); copy(cMyDeque1.begin(),cMyDeque1.end(),cOutput); coutcout endlendl; ; copy(strMyDeque1.begin(),strMyDeque1.end(),strOutput); copy(strMyDeque1.begin(),strMyDeque1.end(),strOutput); cou
134、tcout endlendl; ;（续）续）续）续） / /各个双端队列类型的迭代子被赋值各个双端队列类型的迭代子被赋值各个双端队列类型的迭代子被赋值各个双端队列类型的迭代子被赋值 nItBeginnItBegin =nMyDeque1.begin(); =nMyDeque1.begin(); dblItBegindblItBegin=dblMyDeque1.begin();=dblMyDeque1.begin(); cItBegincItBegin =cMyDeque1.begin(); =cMyDeque1.begin(); strItBeginstrItBegin=strMyDeque1
135、.begin();=strMyDeque1.begin(); ptItBeginptItBegin =ptMyDeque1.begin(); =ptMyDeque1.begin(); nItEndnItEnd =nMyDeque1.end(); =nMyDeque1.end(); dblItEnddblItEnd=dblMyDeque1.end();=dblMyDeque1.end(); cItEndcItEnd =cMyDeque1.end(); =cMyDeque1.end(); strItEndstrItEnd=strMyDeque1.end();=strMyDeque1.end();
136、ptItEndptItEnd =ptMyDeque1.end(); =ptMyDeque1.end(); / /用用用用insertinsert函数实现两个双端队列类型对象成员数据的复制函数实现两个双端队列类型对象成员数据的复制函数实现两个双端队列类型对象成员数据的复制函数实现两个双端队列类型对象成员数据的复制 nMyDeque2.insert(nMyDeque2.begin(),nMyDeque1.begin(),nMyDeque1.end();nMyDeque2.insert(nMyDeque2.begin(),nMyDeque1.begin(),nMyDeque1.end(); for(
137、i=0;inMyDeque2.size();i+) for(i=0;inMyDeque2.size();i+) coutcoutnMyDeque2nMyDeque2i i ; ; coutcoutendlendl; ;（续）续）续）续） dblMyDeque2.insert(dblMyDeque2.begin(),dblMyDeque1.begin(),dblMyDequdblMyDeque2.insert(dblMyDeque2.begin(),dblMyDeque1.begin(),dblMyDeque1.end();e1.end(); for(i=0;idblMyDeque2.size(
138、);i+) for(i=0;idblMyDeque2.size();i+) coutcoutdblMyDeque2dblMyDeque2i i ; ; coutcoutendlendl; ; cMyDeque2.insert(cMyDeque2.begin(),cMyDeque1.begin(),cMyDeque1.end(); cMyDeque2.insert(cMyDeque2.begin(),cMyDeque1.begin(),cMyDeque1.end(); for(i=0;icMyDeque2.size();i+) for(i=0;icMyDeque2.size();i+) cout
139、coutcMyDeque2cMyDeque2i i ; ; coutcoutendlendl; ; strMyDeque2.insert(strMyDeque2.begin(),strMyDeque1.begin(),strMyDequ strMyDeque2.insert(strMyDeque2.begin(),strMyDeque1.begin(),strMyDeque1.end();e1.end(); for(i=0;istrMyDeque2.size();i+) for(i=0;istrMyDeque2.size();i+) coutcoutstrMyDeque2strMyDeque2
140、i i ; ; coutcoutendlendl; ;（续）续）续）续） ptMyDeque2.insert(ptMyDeque2.begin(),ptMyDeque1.begin(),ptMyDeque1.end();ptMyDeque2.insert(ptMyDeque2.begin(),ptMyDeque1.begin(),ptMyDeque1.end(); for(i=0;iptMyDeque2.size();i+) for(i=0;iptMyDeque2.size();i+) intint static count=0; static count=0; if(count=5) if(
141、count=5) count=0; count=0; coutcoutendlendl; ; ptMyDeque2 ptMyDeque2i i.display();.display(); count+; count+; coutcoutendlendl; ; / /用迭代子输出不同双端队列类型对象的数据用迭代子输出不同双端队列类型对象的数据用迭代子输出不同双端队列类型对象的数据用迭代子输出不同双端队列类型对象的数据 while(nItBeginwhile(nItBegin!=!=nItEndnItEnd) ) coutcout*nItBeginnItBegin ; ; nItBeginnItB
142、egin+;+; coutcout endlendl; ;（续）续）续）续） while(dblItBeginwhile(dblItBegin!=!=dblItEnddblItEnd) ) coutcout*dblItBegindblItBegin ; ; dblItBegindblItBegin+=2;+=2; coutcout endlendl; ; while(cItEndwhile(cItEnd!=!=cItBegincItBegin) ) coutcout*(-*(-cItEndcItEnd) ; ) ; coutcout endlendl; ; while(strItBeginwh
143、ile(strItBegin!=!=strItEndstrItEnd) ) coutcout*strItBeginstrItBegin ; ; strItBeginstrItBegin+;+; coutcout endlendl; ; while(ptItBeginwhile(ptItBegin!=!=ptItEndptItEnd) ) （续）续）续）续） intint static count=0; static count=0; if(count=5) if(count=5) count=0; count=0; coutcoutdisplay();-display(); ptItBegin
144、ptItBegin+;+; count+; count+; coutcout endlendl; ; / /用标准算法得到整型双端队列对象中所有数据的和用标准算法得到整型双端队列对象中所有数据的和用标准算法得到整型双端队列对象中所有数据的和用标准算法得到整型双端队列对象中所有数据的和 coutcout The sum of nMyDeque1 The sum of nMyDeque1i i is: is: accumulate(nMyDeque1.begin(),nMyDeque1.end(),0.0f) accumulate(nMyDeque1.begin(),nMyDeque1.end()
145、,0.0f) endlendl; ; / /用标准算法得到双精度型双端队列对象中所有数据的积用标准算法得到双精度型双端队列对象中所有数据的积用标准算法得到双精度型双端队列对象中所有数据的积用标准算法得到双精度型双端队列对象中所有数据的积 coutcout The multiplies of dblMyDeque1 The multiplies of dblMyDeque1i i is:is: accumulate(dblMyDeque1.begin(),dblMyDeque1.end(),1.0f,multiplies() accumulate(dblMyDeque1.begin(),dblM
146、yDeque1.end(),1.0f,multiplies() endlendl; ;（续）续）续）续） / /从字符型双端队列对象中弹出数据从字符型双端队列对象中弹出数据从字符型双端队列对象中弹出数据从字符型双端队列对象中弹出数据 for(i=0;i5;i+)for(i=0;i5;i+) cItEndcItEnd=cMyDeque1.end();=cMyDeque1.end(); coutcoutThe Element will be pop is: *(-The Element will be pop is: *(-cItEndcItEnd)endlendl; ; cMyDeque1.po
147、pback(); cMyDeque1.popback(); cItEndcItEnd=cMyDeque1.end();=cMyDeque1.end(); cItBegincItBegin=cMyDeque1.begin();=cMyDeque1.begin(); / /输出弹出数据后的字符型双端队列对象的数据输出弹出数据后的字符型双端队列对象的数据输出弹出数据后的字符型双端队列对象的数据输出弹出数据后的字符型双端队列对象的数据 while(cItBeginwhile(cItBegin!=!=cItEndcItEnd) ) coutcout*cItBegincItBegin ; ; cItBeg
148、incItBegin+;+; coutcout endlendl; ; nItBeginnItBegin=nMyDeque1.begin();=nMyDeque1.begin(); nItEndnItEnd =nMyDeque1.end(); =nMyDeque1.end();（续）续）续）续） / /用一个已经存在的双端队列对象初始化另一个双端队列对象用一个已经存在的双端队列对象初始化另一个双端队列对象用一个已经存在的双端队列对象初始化另一个双端队列对象用一个已经存在的双端队列对象初始化另一个双端队列对象 dequedeque nMyDeque3(nItBegin,nItEnd); nMyD
149、eque3(nItBegin,nItEnd); dequedeque nMyDeque4(nMyDeque3); nMyDeque4(nMyDeque3); / /输出两个新的双端队列对象输出两个新的双端队列对象输出两个新的双端队列对象输出两个新的双端队列对象 copy(nMyDeque3.begin(),nMyDeque3.end(),nOutput);copy(nMyDeque3.begin(),nMyDeque3.end(),nOutput); coutcout endlendl; ; copy(nMyDeque4.begin(),nMyDeque4.end(),nOutput); co
150、py(nMyDeque4.begin(),nMyDeque4.end(),nOutput); coutcout endlendl; ; / /源程序结束源程序结束源程序结束源程序结束1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 100.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KB C D E F G H I J KI Like C+!I Like C+!1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9
151、 100.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KI Like C+!B C D E F G H I J KI Like C+!Point(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)P
152、oint(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)（续）（续）（续）（续）1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 100.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KB C D E F G H I J KI Like C+!I Like C+!Point(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(1
153、,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)The sum of The sum of nMyDequenMyDequei i is: 55is: 55The multiplies of The multiplies of dblMyDequedblMyDequei i is: 0.00036288is: 0.0003628
154、8The Element will be pop is: KThe Element will be pop is: KThe Element will be pop is: JThe Element will be pop is: JThe Element will be pop is: IThe Element will be pop is: IThe Element will be pop is: HThe Element will be pop is: HThe Element will be pop is: GThe Element will be pop is: GB C D E F
155、B C D E F1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 10 向量、链表和双端队列都具有类似的功能，通常向量、链表和双端队列都具有类似的功能，通常向量、链表和双端队列都具有类似的功能，通常向量、链表和双端队列都具有类似的功能，通常首选使用向量首选使用向量首选使用向量首选使用向量，如果，如果，如果，如果在对象序列中间存在频繁插入和删除操作在对象序列中间存在频繁插入和删除操作在对象序列中间存在频繁插入和删除操作在对象序列中间存在频繁插入和删除操作，这时，这时，这时，这时链表链表链表
156、链表是一种明智的选择，是一种明智的选择，是一种明智的选择，是一种明智的选择，若在对象序列的两端存在频繁的插入和删除操作，则应当选择若在对象序列的两端存在频繁的插入和删除操作，则应当选择若在对象序列的两端存在频繁的插入和删除操作，则应当选择若在对象序列的两端存在频繁的插入和删除操作，则应当选择双端队列双端队列双端队列双端队列。注注注注（续）续）续）续）通过群体类适配子通过群体类适配子通过群体类适配子通过群体类适配子得到栈与队列。得到栈与队列。得到栈与队列。得到栈与队列。适配子适配子适配子适配子是一个提供与群体类接口的模板是一个提供与群体类接口的模板是一个提供与群体类接口的模板是一个提供与群体类接
157、口的模板类，不提供新的服务，只是在原有基本群体类语法的基础上进行重新定义。类，不提供新的服务，只是在原有基本群体类语法的基础上进行重新定义。类，不提供新的服务，只是在原有基本群体类语法的基础上进行重新定义。类，不提供新的服务，只是在原有基本群体类语法的基础上进行重新定义。例例例例 11-511-511-511-5栈应用举例栈应用举例栈应用举例栈应用举例/EXAMPLE11_5.CPP/EXAMPLE11_5.CPP/ /源程序开始源程序开始源程序开始源程序开始# #pragmapragma warning (disable : 4786) warning (disable : 4786) /
158、/防止一个编译警告的出现防止一个编译警告的出现防止一个编译警告的出现防止一个编译警告的出现#include #include #include #include #include #include 标准栈是以标准栈是以标准栈是以标准栈是以LIFOLIFO方式进行访问的，其基本接口函数为方式进行访问的，其基本接口函数为方式进行访问的，其基本接口函数为方式进行访问的，其基本接口函数为pushpush、poppop、sizesize、toptop、emptyempty。 void push(const T& x); void push(const T& x); / / 将对象将对象将对象将对象x x
159、压入栈中压入栈中压入栈中压入栈中void pop(); void pop(); / / 将栈顶元素出栈将栈顶元素出栈将栈顶元素出栈将栈顶元素出栈intint size() const; size() const; / /获得栈中的元素个数获得栈中的元素个数获得栈中的元素个数获得栈中的元素个数const const valuetypevaluetype& top() const; & top() const; / /查询栈顶元素查询栈顶元素查询栈顶元素查询栈顶元素boolbool empty() const; empty() const; / /清空栈清空栈清空栈清空栈【 11.6 11.6 栈
160、与队列栈与队列栈与队列栈与队列】例例例例 11-511-511-511-5using namespace std; using namespace std; / /声明使用声明使用声明使用声明使用stdstd名称空间名称空间名称空间名称空间class Point class Point / /类类类类PointPoint的声明及实现的声明及实现的声明及实现的声明及实现 private: private: / /声明私有数据成员声明私有数据成员声明私有数据成员声明私有数据成员 intint x; x; intint y; y;public: public: / /声明对外接口声明对外接口声明对外
161、接口声明对外接口 Point(intPoint(int xx=0,int xx=0,int yyyy=0) =0) / /带默认形参值的构造函数带默认形参值的构造函数带默认形参值的构造函数带默认形参值的构造函数 x= x=xx;yxx;y= =yyyy; ; void display() void display() / /显示函数显示函数显示函数显示函数 coutcoutPoint(x,y) ;Point(x,y) ; intint getxgetx() const return x;() const return x;intint getygety() const return y;()
162、const return y;boolbool operator =(const Point &point2) const; operator =(const Point &point2) const;栈应用举例栈应用举例栈应用举例栈应用举例boolbool operator (const Point &point2) const; operator (const Point &point2) const; ;boolbool Point:operator =(const Point &point2) const Point:operator =(const Point &point2) co
163、nst if(x=point2.getx()&(y=point2.gety() if(x=point2.getx()&(y=point2.gety() return true ; return true ; else return false ; else return false ; boolbool Point:operator (const Point &point2) const Point:operator (const Point &point2) const if(getxif(getx()point2.getx()&(gety()point2.gety()()point2.ge
164、tx()&(gety()point2.gety() return true ; return true ; else return false ; else return false ; void main ()void main () stack stack nMyStack1; nMyStack1; / /整型栈整型栈整型栈整型栈 stack dblMyStack1; stack dblMyStack1; / /双精度型栈双精度型栈双精度型栈双精度型栈 stack cMyStack1; stack cMyStack1; / /字符型栈字符型栈字符型栈字符型栈（续）续）续）续） stack
165、strMyStack1; stack strMyStack1; / /字符串型栈字符串型栈字符串型栈字符串型栈 stack ptMyStack1; stack ptMyStack1; /Point/Point型栈型栈型栈型栈 / /得到各种栈类型对象中的数据得到各种栈类型对象中的数据得到各种栈类型对象中的数据得到各种栈类型对象中的数据 for(intfor(int i=1;i=10;i+) i=1;i=10;i+) / /用用用用push()push()入栈入栈入栈入栈 nMyStack1.push(i);nMyStack1.push(i); dblMyStack1.push(i/10.0);
166、 dblMyStack1.push(i/10.0); cMyStack1.push(A+i); cMyStack1.push(A+i); Point *point=new Point(i,i); Point *point=new Point(i,i); ptMyStack1.push(*point); ptMyStack1.push(*point); / /用用用用top()top()显示当前栈顶元素显示当前栈顶元素显示当前栈顶元素显示当前栈顶元素 coutcoutnMyStack1.top() ;nMyStack1.top() ; coutcoutdblMyStack1.top() ;dbl
167、MyStack1.top() ; coutcoutcMyStack1.top() ;cMyStack1.top() ; ptMyStack1.top().display(); ptMyStack1.top().display(); coutcout ; ; coutcouti=ii=iendlendl; ; （续）续）续）续） / /用用用用push()push()入栈，用入栈，用入栈，用入栈，用top()top()显示当前栈顶元素显示当前栈顶元素显示当前栈顶元素显示当前栈顶元素 strMyStack1.push(I );strMyStack1.push(I ); coutcoutstrMyS
168、tack1.top();strMyStack1.top(); strMyStack1.push(Like ); strMyStack1.push(Like ); coutcoutstrMyStack1.top();strMyStack1.top(); strMyStack1.push(C+!); strMyStack1.push(C+!); coutcoutstrMyStack1.top();strMyStack1.top(); coutcoutendlendl; ; / /求各个栈中元素数目求各个栈中元素数目求各个栈中元素数目求各个栈中元素数目 coutcoutthe size of nMy
169、Stack1=nMyStack1.size()the size of nMyStack1=nMyStack1.size()endlendl; ; coutcoutthe size of dblMyStack1=dblMyStack1.size()the size of dblMyStack1=dblMyStack1.size()endlendl; ; coutcoutthe size of cMyStack1=cMyStack1.size()the size of cMyStack1=cMyStack1.size()endlendl; ; coutcoutthe size of ptMySta
170、ck1=ptMyStack1.size()the size of ptMyStack1=ptMyStack1.size()endlendl; ; coutcoutthe size of strMyStack1=strMyStack1.size()the size of strMyStack1=strMyStack1.size()endlendl; ; / /用用用用top()top()显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用pop()pop()出栈出栈出栈出栈 for(;!nMyStack1.empty();)for(;!nMyStack1.empty();) cout
171、coutnMyStack1.top() ;nMyStack1.top() ; nMyStack1.pop(); nMyStack1.pop(); coutcoutendlendl; ;（续）续）续）续） / /用用用用top()top()显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用pop()pop()出栈出栈出栈出栈 for(;!dblMyStack1.empty();)for(;!dblMyStack1.empty();) coutcoutdblMyStack1.top() ;dblMyStack1.top() ; dblMyStack1.pop(); dblMyStac
172、k1.pop(); coutcoutendlendl; ; / /用用用用top()top()显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用pop()pop()出栈出栈出栈出栈 for(;!cMyStack1.empty();)for(;!cMyStack1.empty();) coutcoutcMyStack1.top() ;cMyStack1.top() ; cMyStack1.pop(); cMyStack1.pop(); coutcoutendlendl; ; / /用用用用top()top()显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用pop()
173、pop()出栈出栈出栈出栈 for(;!strMyStack1.empty();)for(;!strMyStack1.empty();) coutcoutstrMyStack1.top() ;strMyStack1.top() ; strMyStack1.pop(); strMyStack1.pop();（续）续）续）续） coutcoutendlendl; ; / /用用用用top()top()显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用显示栈顶元素，用pop()pop()出栈出栈出栈出栈 for(;!ptMyStack1.empty();)for(;!ptMyStack1.empty(
174、);) intint static count=0; static count=0; if(count=5) if(count=5) count=0; count=0; coutcoutendlendl; ; ptMyStack1.top().display(); ptMyStack1.top().display(); ptMyStack1.pop(); ptMyStack1.pop(); count+; count+; coutcoutendlendl; ; / /源程序结束源程序结束源程序结束源程序结束（续）续）续）续）1 0.1 B Point(1,1) i=11 0.1 B Point
175、(1,1) i=12 0.2 C Point(2,2) i=22 0.2 C Point(2,2) i=23 0.3 D Point(3,3) i=33 0.3 D Point(3,3) i=34 0.4 E Point(4,4) i=44 0.4 E Point(4,4) i=45 0.5 F Point(5,5) i=55 0.5 F Point(5,5) i=56 0.6 G Point(6,6) i=66 0.6 G Point(6,6) i=67 0.7 H Point(7,7) i=77 0.7 H Point(7,7) i=78 0.8 I Point(8,8) i=88 0.8
176、 I Point(8,8) i=89 0.9 J Point(9,9) i=99 0.9 J Point(9,9) i=910 1 K Point(10,10) i=1010 1 K Point(10,10) i=10I Like C+!I Like C+!The size of nMyStack1=10The size of nMyStack1=10The size of dblMyStack1=10The size of dblMyStack1=10The size of cMyStack1=10The size of cMyStack1=10The size of ptMyStack1=
177、10The size of ptMyStack1=10The size of strMyStack1=3The size of strMyStack1=310 9 8 7 6 5 4 3 2 110 9 8 7 6 5 4 3 2 11 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.11 0.9 0.8 0.7 0.6 0.5 0.4 0.3 0.2 0.1K J I H G F E D C BC+! Like IK J I H G F E D C BC+! Like IPoint(10,10) Point(9,9) Point(8,8) Point(7,7) Point
178、(6,6)Point(10,10) Point(9,9) Point(8,8) Point(7,7) Point(6,6)Point(5,5) Point(4,4) Point(3,3) Point(2,2) Point(1,1)Point(5,5) Point(4,4) Point(3,3) Point(2,2) Point(1,1) 队列的访问方式队列的访问方式队列的访问方式队列的访问方式是是是是FIFOFIFO，队列的主队列的主队列的主队列的主要函数与栈相似：要函数与栈相似：要函数与栈相似：要函数与栈相似：frontfront返回队列首部返回队列首部返回队列首部返回队列首部对象的引用、对
179、象的引用、对象的引用、对象的引用、backback返回队列尾对象的返回队列尾对象的返回队列尾对象的返回队列尾对象的引用，引用，引用，引用，pushpush入队到入队到入队到入队到队列尾，队列尾，队列尾，队列尾，poppop从队首从队首从队首从队首出队，出队，出队，出队，emptyempty判断队判断队判断队判断队空，空，空，空，sizesize获得队中元获得队中元获得队中元获得队中元素数目。素数目。素数目。素数目。注注注注（续）续）续）续）集合与映射是两种主要的非线性群体类，集合与映射是两种主要的非线性群体类，集合与映射是两种主要的非线性群体类，集合与映射是两种主要的非线性群体类，对集合与映射
180、的概念的理解与数对集合与映射的概念的理解与数对集合与映射的概念的理解与数对集合与映射的概念的理解与数学上的概念相类比。学上的概念相类比。学上的概念相类比。学上的概念相类比。主要通过集合来学习主要通过集合来学习主要通过集合来学习主要通过集合来学习STLSTL中非线性群体类的用法。中非线性群体类的用法。中非线性群体类的用法。中非线性群体类的用法。例如例如例如例如: :自集、交集、差集，通过自集、交集、差集，通过自集、交集、差集，通过自集、交集、差集，通过includesincludes、setintersectionsetintersection、 setdifferencesetdifferen
181、ce等函等函等函等函数实现的。数实现的。数实现的。数实现的。 template class InIt1,class InIt2, class template OutItOutIt setdifference(InIt1 first1,InIt1 last1,InIt2 first2, InIt2 last2, setdifference(InIt1 first1,InIt1 last1,InIt2 first2, InIt2 last2, OutItOutIt x); x); 该函该函该函该函数将集合数将集合数将集合数将集合InIt1InIt1中从中从中从中从first1first1到到到到
182、last1last1中的元素与集合中的元素与集合中的元素与集合中的元素与集合InIt2InIt2中从中从中从中从first2first2到到到到last2last2中的元素进中的元素进中的元素进中的元素进行比较，将属于行比较，将属于行比较，将属于行比较，将属于InIt1InIt1但不属于但不属于但不属于但不属于InIt2InIt2的元素形成一个序列，由的元素形成一个序列，由的元素形成一个序列，由的元素形成一个序列，由x x指示指示指示指示 ( (本例中将符本例中将符本例中将符本例中将符合条件的元素用合条件的元素用合条件的元素用合条件的元素用inserterinserter函数插入到新的集合中函
183、数插入到新的集合中函数插入到新的集合中函数插入到新的集合中) )。template class InIt1,class InIt2, class template OutItOutIt setintersection(InIt1 first1,InIt1 last1,InIt2 first2, InIt2 last2, setintersection(InIt1 first1,InIt1 last1,InIt2 first2, InIt2 last2, OutItOutIt x); x);该函该函该函该函数用法与数用法与数用法与数用法与setdifferencesetdifference相同，
184、求两个集合的交集。相同，求两个集合的交集。相同，求两个集合的交集。相同，求两个集合的交集。template template boolbool includes(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2); includes(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2); 该函数求该函数求该函数求该函数求InIInIt2t2所指示的集合范围所指示的集合范围所指示的集合范围所指示的集合范围(first2,last2)(first2,last2)是否是是否是是否是是否是In
185、It1InIt1所指示的集合范围所指示的集合范围所指示的集合范围所指示的集合范围(first1,last1)(first1,last1)的子集。的子集。的子集。的子集。【 11.7 11.7 集合集合集合集合】集合应用举例集合应用举例集合应用举例集合应用举例/EXAMPLE11_6.CPP/EXAMPLE11_6.CPP/ /源程序开始源程序开始源程序开始源程序开始# #pragmapragma warning (disable : 4786) warning (disable : 4786) / /防止一个编译警告的出现防止一个编译警告的出现防止一个编译警告的出现防止一个编译警告的出现#in
186、clude #include #include #include #include #include #include #include #include #include using namespace std; using namespace std; / /声明使用声明使用声明使用声明使用stdstd名称空间名称空间名称空间名称空间class Point class Point / /类类类类PointPoint的声明及实现的声明及实现的声明及实现的声明及实现 private: private: / /声明私有数据成员声明私有数据成员声明私有数据成员声明私有数据成员 intint x;
187、x; intint y; y;public: public: / /声明对外接口声明对外接口声明对外接口声明对外接口 Point(intPoint(int xx=0,int xx=0,int yyyy=0) =0) / /带默认形参值的构造函数带默认形参值的构造函数带默认形参值的构造函数带默认形参值的构造函数例例例例 11-611-611-611-6 x= x=xx;yxx;y= =yyyy; ; void display() void display() / /显示函数显示函数显示函数显示函数 coutcoutPoint(x,y) ;Point(x,y) ; intint getxgetx(
188、) const return x;() const return x; intint getygety() const return y;() const return y; boolbool operator=(const Point &point2) const; operator=(const Point &point2) const; / /必须重载必须重载必须重载必须重载=和和和和 运算符运算符运算符运算符 boolbool operator(const Point &point2) const; operator(const Point &point2) const; ;boolb
189、ool Point:operator =(const Point &point2) const Point:operator =(const Point &point2) const if(x=point2.getx()&(y=point2.gety() if(x=point2.getx()&(y=point2.gety() return true ; return true ; else return false ; else return false ; （续）（续）（续）（续）boolbool Point:operator (const Point &point2) const Poin
190、t:operator (const Point &point2) const if(getxif(getx()point2.tetx()&KG-*4&(gety()point2.gety()()point2.tetx()&KG-*4&(gety()point2.gety() return true ; return true ; else return false ; else return false ; void main ()void main () set set nMySet1 , nMySet1 ,nMySetDifference,nMySetIntersectionnMySetD
191、ifference,nMySetIntersection; ; / /整型集合整型集合整型集合整型集合 set dblMySet1,dblMySetDifference,dblMySetIntersection; set dblMySet1,dblMySetDifference,dblMySetIntersection; / /双精度型双精度型双精度型双精度型 / /集合集合集合集合 set cMySet1,cMySetDifference,cMySetIntersection; set cMySet1,cMySetDifference,cMySetIntersection; / /字符型集合
192、字符型集合字符型集合字符型集合 set strMySet1,strMySetDifference,strMySetIntersection; set strMySet1,strMySetDifference,strMySetIntersection; / /字符串型集合字符串型集合字符串型集合字符串型集合 set ptMySet1,ptMySetDifference,ptMySetIntersection; set ptMySet1,ptMySetDifference,ptMySetIntersection; /Point/Point型集合型集合型集合型集合 / /针对不同集合类型的迭代子针对
193、不同集合类型的迭代子针对不同集合类型的迭代子针对不同集合类型的迭代子（续）（续）（续）（续） set set: :iteratoriterator nItBegin1,nItEnd1, nItBegin1,nItEnd1, nItBegin2,nItEnd2; nItBegin2,nItEnd2; set: set:iteratoriterator dblItBegin1,dblItEnd1, dblItBegin1,dblItEnd1, dblItBegin2,dblItEnd2; dblItBegin2,dblItEnd2; set: set:iteratoriterator cItBeg
194、in1,cItEnd1, cItBegin1,cItEnd1, cItBegin2,cItEnd2; cItBegin2,cItEnd2; set: set:iteratoriterator strItBegin1,strItEnd1, strItBegin1,strItEnd1, strItBegin2,strItEnd2; strItBegin2,strItEnd2; set: set:iteratoriterator ptItBegin1,ptItEnd1, ptItBegin1,ptItEnd1, ptItBegin2,ptItEnd2; ptItBegin2,ptItEnd2; /
195、/针对不同集合类型的输出流迭代子针对不同集合类型的输出流迭代子针对不同集合类型的输出流迭代子针对不同集合类型的输出流迭代子 ostream_iteratorostream_iterator nOutput(coutnOutput(cout, );, ); ostream_iteratorostream_iterator dblOutput(coutdblOutput(cout, );, ); ostream_iteratorostream_iterator cOutput(coutcOutput(cout, );, ); ostream_iteratorostream_iterator str
196、Output(coutstrOutput(cout, );, ); / /得到各种集合类型对象中的数据得到各种集合类型对象中的数据得到各种集合类型对象中的数据得到各种集合类型对象中的数据 for(intfor(int i=1;i=10;i+) i=1;i=10;i+) nMySet1.insert(i); nMySet1.insert(i);（续）（续）（续）（续） dblMySet1.insert(i/10.0);dblMySet1.insert(i/10.0); cMySet1.insert(A+i); cMySet1.insert(A+i); Point *point=new Point
197、(i,i); Point *point=new Point(i,i); ptMySet1.insert(*point); ptMySet1.insert(*point); strMySet1.insert(I ); strMySet1.insert(I ); strMySet1.insert(Like ); strMySet1.insert(Like ); strMySet1.insert(C+!); strMySet1.insert(C+!); / /将不同集合类型对象中的数据输出到标准输出流，显示出来。将不同集合类型对象中的数据输出到标准输出流，显示出来。将不同集合类型对象中的数据输出到标
198、准输出流，显示出来。将不同集合类型对象中的数据输出到标准输出流，显示出来。 copy(nMySet1.begin(),nMySet1.end(),nOutput);copy(nMySet1.begin(),nMySet1.end(),nOutput); coutcout endlendl; ; copy(dblMySet1.begin(),dblMySet1.end(),dblOutput); copy(dblMySet1.begin(),dblMySet1.end(),dblOutput); coutcout endlendl; ; copy(cMySet1.begin(),cMySet1.
199、end(),cOutput); copy(cMySet1.begin(),cMySet1.end(),cOutput); coutcout endlendl; ; copy(strMySet1.begin(),strMySet1.end(),strOutput); copy(strMySet1.begin(),strMySet1.end(),strOutput); coutcout endlendl; ; / /各个集合类型的迭代子被赋值各个集合类型的迭代子被赋值各个集合类型的迭代子被赋值各个集合类型的迭代子被赋值 nItBegin1 =nMySet1.begin();nItBegin1 =n
200、MySet1.begin();（续）（续）（续）（续） dblItBegin1=dblMySet1.begin();dblItBegin1=dblMySet1.begin(); cItBegin1 =cMySet1.begin(); cItBegin1 =cMySet1.begin(); strItBegin1=strMySet1.begin(); strItBegin1=strMySet1.begin(); ptItBegin1 =ptMySet1.begin(); ptItBegin1 =ptMySet1.begin(); nItEnd1 =nMySet1.end(); nItEnd1 =
201、nMySet1.end(); dblItEnd1=dblMySet1.end(); dblItEnd1=dblMySet1.end(); cItEnd1 =cMySet1.end(); cItEnd1 =cMySet1.end(); strItEnd1=strMySet1.end(); strItEnd1=strMySet1.end(); ptItEnd1 =ptMySet1.end(); ptItEnd1 =ptMySet1.end(); / /用一个集合对象初始化另一个集合对象用一个集合对象初始化另一个集合对象用一个集合对象初始化另一个集合对象用一个集合对象初始化另一个集合对象 set s
202、et nMySet2(nMySet1), nMySet3(nMySet2); nMySet2(nMySet1), nMySet3(nMySet2); set dblMySet2(dblMySet1), dblMySet3(dblMySet2); set dblMySet2(dblMySet1), dblMySet3(dblMySet2); set cMySet2(cMySet1), cMySet3(cMySet2); set cMySet2(cMySet1), cMySet3(cMySet2); set strMySet2(strMySet1), strMySet3(strMySet2); s
203、et strMySet2(strMySet1), strMySet3(strMySet2); set ptMySet2(ptMySet1), ptMySet3(ptMySet2); set ptMySet2(ptMySet1), ptMySet3(ptMySet2); nItBegin2 =nMySet2.begin(); nItBegin2 =nMySet2.begin(); dblItBegin2=dblMySet2.begin(); dblItBegin2=dblMySet2.begin(); cItBegin2 =cMySet2.begin(); cItBegin2 =cMySet2.
204、begin(); strItBegin2=strMySet2.begin(); strItBegin2=strMySet2.begin(); ptItBegin2 =ptMySet2.begin(); ptItBegin2 =ptMySet2.begin();（续）（续）（续）（续） nItEnd2 =nMySet2.end();nItEnd2 =nMySet2.end(); dblItEnd2=dblMySet2.end(); dblItEnd2=dblMySet2.end(); cItEnd2 =cMySet2.end(); cItEnd2 =cMySet2.end(); strItEnd
205、2=strMySet2.end(); strItEnd2=strMySet2.end(); ptItEnd2 =ptMySet2.end(); ptItEnd2 =ptMySet2.end(); / /用迭代子输出不同集合类型对象的数据用迭代子输出不同集合类型对象的数据用迭代子输出不同集合类型对象的数据用迭代子输出不同集合类型对象的数据 while(nItBegin2!=nItEnd2)while(nItBegin2!=nItEnd2) coutcout*nItBegin2 ;*nItBegin2 ; nItBegin2+; nItBegin2+; coutcout endlendl; ; w
206、hile(dblItBegin2!=dblItEnd2) while(dblItBegin2!=dblItEnd2) coutcout*dblItBegin2 ;*dblItBegin2 ; dblItBegin2+; dblItBegin2+; coutcout endlendl; ;（续）（续）（续）（续） while(cItEnd2!=cItBegin2)while(cItEnd2!=cItBegin2) coutcout*(-cItEnd2) ;*(-cItEnd2) ; coutcout endlendl; ; while(strItBegin2!=strItEnd2) while(
207、strItBegin2!=strItEnd2) coutcout*strItBegin2 ;*strItBegin2 ; strItBegin2+; strItBegin2+; coutcout endlendl; ; while(ptItBegin2!=ptItEnd2) while(ptItBegin2!=ptItEnd2) intint static count=0; static count=0; if(count=5) if(count=5) count=0; count=0; coutcoutdisplay();ptItBegin2-display(); ptItBegin2+;
208、ptItBegin2+; count+; count+; coutcout endlendl; ; / /对对对对* *MySet2MySet2的各种集合类型对象增加数据的各种集合类型对象增加数据的各种集合类型对象增加数据的各种集合类型对象增加数据 for(i=1;i=5;i+)for(i=1;i=5;i+) nMySet2.insert(i+10); nMySet2.insert(i+10); / /求两个集合的差和交求两个集合的差和交求两个集合的差和交求两个集合的差和交 setdifference(nMySet2.begin(),nMySet2.end(),nMySet1.begin(),
209、nMySet1.end(),setdifference(nMySet2.begin(),nMySet2.end(),nMySet1.begin(),nMySet1.end(), inserter(nMySetDifference,nMySetDifference.begininserter(nMySetDifference,nMySetDifference.begin();(); setintersection(nMySet1.begin(),nMySet1.end(),nMySet2.begin(),nMySet2.end(), setintersection(nMySet1.begin()
210、,nMySet1.end(),nMySet2.begin(),nMySet2.end(), inserter(nMySetIntersection,nMySetIntersection.begininserter(nMySetIntersection,nMySetIntersection.begin();(); if(includes(nMySet2.begin(),nMySet2.end(),nMySet3.begin(),nMySet3.end() if(includes(nMySet2.begin(),nMySet2.end(),nMySet3.begin(),nMySet3.end()
211、 （续）（续）（续）（续） coutcoutnMySet3 is a subset of nMySet2!nMySet3 is a subset of nMySet2!endlendl; ; else else coutcoutnMySet3 is not a subset of nMySet2!nMySet3 is not a subset of nMySet2!endlendl; ; coutcout nMySet2s elements are: ; nMySet2s elements are: ; copy(nMySet2.begin(),nMySet2.end(),nOutput);
212、copy(nMySet2.begin(),nMySet2.end(),nOutput); coutcout endlendl; ; coutcoutnMySetDifferencesnMySetDifferences elements are: ; elements are: ; copy(nMySetDifference.begin(),nMySetDifference.end(),nOutputcopy(nMySetDifference.begin(),nMySetDifference.end(),nOutput); ); coutcout endlendl; ; coutcoutnMyI
213、ntersectionsnMyIntersections elements are: ; elements are: ; copy(nMySetIntersection.begin(),nMySetIntersection.end(),nOutputcopy(nMySetIntersection.begin(),nMySetIntersection.end(),nOutput); ); coutcout endlendl; ; / /源程序结束源程序结束源程序结束源程序结束（续）（续）（续）（续）1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 101.1 0.2 0
214、.3 0.4 0.5 0.6 0.7 0.8 0.9 11.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KB C D E F G H I J KC+! I LikeC+! I Like1 2 3 4 5 6 7 8 9 101 2 3 4 5 6 7 8 9 100.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 10.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1B C D E F G H I J KB C D E F G H I J KC+! I LikeC+! I LikePoint
215、(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(1,1) Point(2,2) Point(3,3) Point(4,4) Point(5,5)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)Point(6,6) Point(7,7) Point(8,8) Point(9,9) Point(10,10)nMySet3 is a subset of nMySet2!nMySet3 is a subset of nMySet2!nMySet2s elements are:
216、1 2 3 4 5 6 7 8 9 10 11 12 13 14 15nMySet2s elements are: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15nMySetDifferencesnMySetDifferences elements are: 11 12 13 14 15 elements are: 11 12 13 14 15nMySetIntersectionsnMySetIntersections elements are: 1 2 3 4 5 6 7 8 9 10 elements are: 1 2 3 4 5 6 7 8 9 10（续）（续）（续）（续）
