首页  思维导图  详情

16章 string类和标准模板库

2020-02-24 10:29:02   9  举报





AI智能生成

C++ Plus 笔记

C++

作者其他创作

大纲/内容

标准模板库

内容

容器、迭代器、函数对象和算法的模板

模板类vector

条件

头文件

#include<vector><br>

名称空间

using namespace std;

声明

vector<double> v1;

初始化

vector<double> v2(5);

包含5个元素的vector数组

<div>vector<int> vec; //声明一个int型向量 </div><div>vector<int> vec(5); //声明一个初始大小为5的int向量 </div><div>vector<int> vec(10, 1); //声明一个初始大小为10且值都是1的向量 </div><div>vector<int> vec(tmp); //声明并用tmp向量初始化vec向量 </div><div>vector<int> tmp(vec.begin(), vec.begin() + 3); //用向量vec的第0个到第2个值初始化tmp </div><div>int arr[5] = {1, 2, 3, 4, 5}; </div><div>vector<int> vec(arr, arr + 5); //将arr数组的元素用于初始化vec向量 </div><div>//说明：当然不包括arr[4]元素，末尾指针都是指结束元素的下一个元素， //这个主要是为了和vec.end()指针统一。 </div><div>vector<int> vec(&arr[1], &arr[4]); //将arr[1]~arr[4]范围内的元素作为vec的初始值</div>

子主题

访问元素

下标 v1[0]//和数组一样

vector<int>rating(5)<br>for(int i=0;i<5;i++)<br>       cout<<rating[i]<<endl;

迭代器

声明

vector<double>::iterator pd;

相当于一个指针一样

赋值

vector<double>scores;<br>pd=score.begin();

....

初始化

vector::iterator pd=score.begin();

C++11中可以<br>auto pd=score.begin();

基本操作

前提

vector<double>::iterator pd;<br>vector<double>scores;<br>pd=score.begin();<br></double>

*(解析运算符)

*pd=22.3

scores数组第一个元素值为22.3

++/--

++pd;

指向scores数组的下一个元素

应用

遍历容器内容

for( pd=score.begin() ; pd != scores.end() ; pd++ )<br>         cout<<*pd<<endl;

基本的方法

几乎所有<br>STL容器都有

size()

swap()

vector<double>vec1;<br>vector<double>vec2;<br><br>vec1.swap(vec2);//交换vec1与vec2的内容

begin()

end() //标识超过结尾的位置。不是最后一个元素

其他

push_back()

<span style="color: rgb(75, 75, 75);"><span style="font-size: 13px;"><span style="font-family: verdana, Arial, helvetica, sans-seriff;">vec.push_back(</span></span></span> <span style="color: rgb(153, 0, 0); font-family: Verdana; font-size: 12px; widows: auto;">elem</span> <span style="color: rgb(75, 75, 75);"><span style="font-size: 13px;"><span style="font-family: verdana, Arial, helvetica, sans-seriff;">);//在末尾添加新元素</span></span></span>

erase()

格式

vec.erase(vec.begin()+2);删除第3个元素

vec.erase(vec.begin()+i,vec.end()+j);删除区间  [i,j）;区间从0开始

注意STL区间用[ p1,p2 )来表示从p1到p2(不包括)的区间

说明

删除后，后面的字母会自动向前移

insert()

格式

vec.insert(  vec.begin()+i , a );//在第i-1个元素前插入a元素

vec.insert(  vec.begin()+i , n , a );//在第i-1个元素前插入n 个 a元素

vector<double> vec1;<br>vector<double>vec2;<br><br>vec1.insert( vec1.begin() , vec2.begin()+1 , vec2.end()  )  //将vec2 的除第一个元素插入到vec1中

STL方法<br>（非成员函数）

for_each()

格式

vector<Review>book;//Review 是一个结构体<br>for_each( book.begin() , book.end() , ShowReview );  // ShowReview 是一个普通函数，显示Review中的内容

struct Review{<br>     std::string title;<br>     int rating;<br>};

void ShowReview( const Revie & rr)<br>{<br>      std:cout<<rr.rating<<" "<<rr.title<<std::endl;<br>}

作用

代替for循环，可替换一下代码

vector<Review>::iterator pr;<br>for(pr = book.begin() ;pr != book.end() , pr++ )<br>     ShowReview( *pr );

为什么很多时候不直接用<br>for(int i=0;i<book.size();i++)<br>          Show(book[i]);<br>//而用迭代器呢？

random_shuffle()

格式

random_shuffle(book.begin() , book.end() );

作用

随机排列该区间的元素

sort()

第一种版本<br>（两个参数）

作用

只能按升序对vector类对象进行排列

格式

基本数据

vector<int> coolstuff;<br>...<br>sort(coolstuff.begin() , coolstuff.end() );

说明

会自动从小到大（升序）排列

用户自定义类<br>(结构，类)

sort（book.begin() , book.end()）;// 只是这样还不行，必须定义能够处理<br>                                                              该类型对象的operator<()函数 

bool operator<(const Review &r1, const Review &r2 )<br>{<br>         return r1.title < r2.title;<br>}

说明

bool operator< （）直接在main外部声明即可，不需要什么限定域

上版本operator<(）函数按title成员的字母排序，如果title相同，则<br>按rating排序。

第二种版本

作用

不想按升序排序，或者其它。vector对象是用户自定义类型，<br>除了上面方法，也可以用这个方法

格式

sort（book.begin() , book.end() ,Comp）;

bool Comp( const Review & r1 , const Review & r2)<br>{<br>    return r1.rating<r2.rating;<br>}

说明

sort（）把book.begin() ... 中的元素传递给Comp

bool Comp()也是直接在main()外部即可

与operator<()相比，Comp（）函数排序不太完整。<br>两个对象中的title成员相同，operator<()将按rating进行排序，<br>Comp（）视它们为一样。<br>operator<——全排序<br>Comp()——完整弱排序

<b>问题！！</b>如果自定义类型是类，需要按它的私有成员排序怎么办？

按类对象私有数据排序<br>

代码

<div>#include<iostream></div><div>#include<algorithm></div><div>#include<vector></div><div>using namespace std;</div><div>class Text{</div><div><br></div><div>public:</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Text(int aa,int bb):a(aa),b(bb){}</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>int & Geta(){ return a;}</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>int & Getb(){ return b;}</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>void show(){ cout<<a;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>}</div><div>//protect:</div><div><span class="Apple-tab-span" style="white-space:pre"> </span></div><div>private:</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>int a;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>int b;</div><div><br></div><div>};  </div><div>bool Comp(Text &T1,Text &T2);</div><div>int main()</div><div>{</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>vector<Text>  vec;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Text t1(1,1);</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Text t2(2,2);</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Text t3(3,3);</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>vec.push_back(t1);</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>vec.push_back(t3);</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>vec.push_back(t2);</div><div><span class="Apple-tab-span" style="white-space:pre"> </span></div><div><span class="Apple-tab-span" style="white-space:pre"> </span>vec[0].show();vec[1].show();vec[2].show();</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>cout<<endl;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>sort(vec.begin(),vec.end(),Comp);</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>vec[0].show();vec[1].show();vec[2].show();</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>cout<<endl;</div><div>}</div><div>bool Comp(Text &T1,Text &T2)</div><div>{</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>return (T1.Geta()<T2.Geta());</div><div>}</div>

说明

在devC++上运行不了、

在visualC++6.0上可以运行

copy算法

作用

将数据从一个容器复制到另一个容器中。算法以迭代器方式实现。<br>可以在数组之间复制。

格式

copy( cats , cats+10 , dice.begin() );<br>

说明

前两个参数表示要复制的范围。（最好是输入迭代器）<br>最后一个参数表示要将第一个元素复制到什么位置。（最好是输出迭代器）

例子

int cats[10] = { 6,7,2,9,4,11,8,7,10,5};<br>vector<int> dice（10）;<br>copy( cast , cast + 10 ,dice.begin() );

copy会覆盖原来迭代器的内容。<br>不能使用copy()将数据放到空矢量中。vector<int>dice(10) 一定要有10；

作用

将信息复制到显示器上。把第三个参数表示输出流的迭代器。

输出流迭代器

头文件

#include<iterator.h>

模板

ostream_iterator

该模板是输出迭代器概念的一个模型，也是一个适配器——一个类或函数。

创建

声明

ostream_iterator<int,char> out_iter(cout , " " );

说明

模板参数

第一个参数

指出被发送给输出流的数据类型

第二个参数

指出了输出流使用的字符类型

//!!!可以省略，默认和前面的相同。哪个可以省略？？不知道

构造函数参数

第一个参数

要使用输出流//可是是cout，可以是文件

第二个参数

在发送给输出流的每个数据项后显示的分隔符

例子

*out_iter++ = 15;

说明

将15由空格组成的字符串发送到cout管理的输出流中，并为下一个输出操作做好了准备。（指针+1）

相当于cout<<15<<" ";

例子

int cats[10] = { 6,7,2,9,4,11,8,7,10,5};<br>vector<int> dice（10）;<br>copy( cast , cast + 10 ,dice.begin() );<br><br>ostream_iterator<int,char> out_iter<int , char>(cout , " " );<br><b>copy（dice.begin() , dice.end() , out_iter);<br>//显示器输出6 7 2 9 4 11 8 7 10 5（有空格）</b></int,char>

<b>//不创建命名迭代器<br>copy（dice.begin() , dice.end() , ostream_iterator<int,char>(cout," "));</b>

作用

把输入流的信息复制到数组上

输入流迭代器

头文件

#include<iterator.h>

模板

ostream_iterator

创建

声明

istream_iterator<int,char> in_iter1(cin);<br>istream_iterator<int,char> in_iter2()；<br>

说明

模板参数

第一个参数

指出要读取的数据类型

第二个参数

输入流使用的字符类型

构造函数参数

使用参数cin表示由cin管理的输入流。//可以是文件

不用参数表示输入失败

例子

istream_iterator<int,char> in_iter1<int,char>(cin);<br>istream_iterator<int,char> in_iter2<int,char>()；<br><br>copy(in_iter1,in_iter2,dice.begin());</int,char></int,char>

表示代码从输入流中读取，直到文件结尾、类型不匹配或出现其他输入故障。

copy(istream_iterator <int,char>(cin),stream_iterator<int,char><int,char>()</int,char>,dice.begin());

基于范围的for循环

格式

double price[5] = {4.99 , 10.99 , 6.99 , 6.87 , 7.99 , 8.49};<br>for ( double x:prices )<br>       cout<<x<<std::endl;

说明

price的那个位置要求是一种容器。<br>x前面的类型与容器存储的类型相同。

foreach改成基于范围的for循环

for_each( book.begin() , book.end() , Showview);<br>相当于<br>for( auto x ： books ) ShowReview(x);

说明

for_each()中的函数（上是Showview）不能修改容器中的数据；<br>基于范围的for循环可以修改。

eg:有<br>viod InflateReview( Review & r){  r.rating++; }<br><br>只能是：<br>for( auto <font color="#c41230">& x</font>: books ) InflateReview(x);//注意有&！！！

泛型编程

前言

STL是一种泛型编程

面向对象编程——关注编程数据方面<br>泛型编程——关注算法<br>

泛型编程旨在独立于数据类型的代码。完成独立于数据类<br>型的工具——模板、模板基础+STL（通过算法）。<br>但必须对元素进行仔细的设计。（如何设计？）

迭代器

为何使用迭代器

作用

模板使算法独立于存储的数据类型。<br>迭代器使算法独立于容器的类型。

<span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">泛型编程旨在使用同一个find函数来处理数组,链表或任何其他容器类型.</span><br>

<span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">首先是处理容器的算法,应尽可能用通用的术语来表达算法,使之独立于数据类型和容器类型.<br>为使通用算法能够适用于具体情况,应定义能够满足算法需求的迭代器(迭代器正是这样的通用表示),<br>并把要求加到容器设计上.<br>即基于算法的要求,</span><span style="font-family: 'microsoft yahei'; line-height: 26px;"><font color="#c41230">设计基本迭代器的特征和容器特征.</font></span><br>

如何为两种不同数<br>据实现find函数

double数组

<div>Double *find_ar( double * ar , int n , const double & val )</div><div>{</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>for(int i=0 ; i<n ; i++)</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>if( ar[i] == val )</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>return &ar[i];</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>return 0;</div><div>}</div><div><br></div>

改进（设计迭代器）

<div>//改进1<br>Typedef double *iterator;</div><div>iterator find_ar(iterator ar,int n , const double &val )</div><div>{</div><div>for(int i = 0 ; i < n; i++ ,ar++  )</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>if( *ar == val)</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>return ar;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>return 0;</div><div>}</div>

//改进2<br><div>Typedef double *iterator;</div><div>iterator find_ar(iterator begin ,iterator end , const double &val )</div><div>{</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>iterator ar;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>for(ar = begin ; ar != end ; ar++ )</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>if( *ar == val)</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>return ar;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>return end;</div><div>}</div>

Node结构

<div>struct Node</div><div>{</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>double item;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Node * p->next;</div><div>};</div><div><br></div><div>Node* find_ll( Node *head, const double &val )</div><div>{</div><div>Node * start;</div><div>for (start = head; start != 0; start = start->next)</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>if( start -> item == val )</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>return start;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>return 0;</div><div>}</div>

改进（设计迭代器）

//改进1<br><div>struct Node</div><div>{</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>double item;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Node * p->next;</div><div>};</div><div>//迭代器设计</div><div>class iterator</div><div>{</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Node * pt;</div><div>Public:</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Iterator() :pt(0) {}</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Iterayor( Node * pn ) : pt(pn){}</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Double operator*() {return pt->item;}</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Iterator& operator()</div><div>{<span class="Apple-tab-span" style="white-space:pre"> </span></div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Pt = pt -> p_next;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Return *this;</div><div>}</div><div>Iterator operator++(int)</div><div>{</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>iterator tmp = *this;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Pt = pt->p_next;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Return temp;</div><div>}</div><div>// …..operator==(),….</div><div>};</div><div><br></div><div>//设计迭代器后的方程</div><div>Interator find_ll( iterator head, const double & val)</div><div>{</div><div>Iterayor start;</div><div>For(start = head; start != 0 ; ++start)</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>If( *start == val)</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Return start;</div><div><span class="Apple-tab-span" style="white-space:pre"> </span>Return 0;</div><div>}</div>

//改进2<br>设计超尾元素，使与double的改进2差不多

迭代器简要介绍

<div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>http://www.cnblogs.com/besty/p/4039264.html</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>1. 迭代器(iterator)是一中检查容器内元素并遍历元素的数据类型。</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><br></b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>(1) 每种容器类型都定义了自己的迭代器类型，如vector:</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><span class="Apple-tab-span" style="white-space:pre"> </span>vector<int>::iterator iter;这条语句定义了一个名为iter的变量，它的数据类型是由vector<int>定义的iterator类型。</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><br></b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>(2) 使用迭代器读取vector中的每一个元素：</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><br></b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>①iterator 可修改元素</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>vector<int> ivec(10,1);</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>for(vector<int>::iterator iter=ivec.begin();iter!=ivec.end();++iter)</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>{</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><span class="Apple-tab-span" style="white-space:pre"> </span>*iter=2; //使用 * 访问迭代器所指向的元素</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>}</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>②const_iterator:</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>只能读取容器中的元素，而不能修改。</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>for(vector<int>::const_iterator citer=ivec.begin();citer!=ivec.end();citer++)</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>{</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><span class="Apple-tab-span" style="white-space:pre"> </span>cout<<*citer;</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><span class="Apple-tab-span" style="white-space:pre"> </span>//*citer=3; error</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>}</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>③vector<int>::const_iterator 和 const vector<int>::iterator的区别</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>const vector<int>::iterator newiter=ivec.begin();</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>*newiter=11; //可以修改指向容器的元素</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>//newiter++; //迭代器本身不能被修改 </b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><br></b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>(3) iterator的算术操作：</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>①iterator进行++,--操作，</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>②可以将iter+n,iter-n赋给一个新的iteraor对象。</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>③使用一个iterator减去另外一个iterator.</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><span class="Apple-tab-span" style="white-space:pre"> </span>const vector<int>::iterator newiter=ivec.begin();</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><span class="Apple-tab-span" style="white-space:pre"> </span>vector<int>::iterator newiter2=ivec.end();</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><span class="Apple-tab-span" style="white-space:pre"> </span>cout<<"\n"<<newiter2-newiter; </b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><br>(4)一個很典型使用vector的STL程式:</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>#include <vector></b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>#include <iostream></b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><br></b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>using namespace std;</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b><br></b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b>int main() {</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b> vector<int> ivec;</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b> ivec.push_back(1);</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b> ivec.push_back(2);</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b> ivec.push_back(3);</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b> ivec.push_back(4);</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b> </b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b> for(vector<int>::iterator iter = ivec.begin();  iter != ivec.end(); ++iter)</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b> <span class="Apple-tab-span" style="white-space:pre"> </span>cout << *iter << endl;</b></span></font></div><div><font color="#000000" face="verdana"><span style="line-height: 22.4px;"><b> }</b></span></font></div>

迭代器的类型

不同迭代器的区别

重载的运算符不一样，能执行的操作不一样。<br>eg：有些迭代器可以修改数据，有些不可以

类型

输入迭代器

操作

*iter

读取元素实际的值，只能作为左值

iter->member

读取实际元素的成员（如果有的话）

++iter

<div>向前步进（传回新位置）</div>

iter++

向前步进（传回旧位置）

iter1 == iter2

<div>判断两个迭代器是否相同</div>

iter1 != iter2   

判断两个迭代器是否不相等

TYPE(iter)

复制迭代器（copy 构造函数）

说明

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;"><li style="box-sizing: border-box;">输入迭代器可被程序用来读取容器中的信息.</li></ul>

对迭代器解除引用也不能修改值

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;"><li style="box-sizing: border-box;">并不能保证输入迭代器第二次遍历容器时,顺序不变.另外,输入迭代器被递增后,也不能保证其先前的值仍然可以被解除引用.基于输入迭代器的任何算法都应当是单通行(single-pass)的,不依赖于前一次遍历时的迭代器值,也不依赖于本次遍历汇总前面的迭代器值.</li></ul>

不理解，例子？

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;"><li style="box-sizing: border-box;">注意,输入迭代器是单向迭代器,可以递增,但不能倒退.</li></ul>

输出迭代器

操作

<div>表达式                  功能表述</div><div>*iter = value      将元素写入到迭代器所指位置</div><div>++iter             向前步进（传回新位置）</div><div>iter++             向前步进（传回旧位置）<br><div>iter1 == iter2      判断两个迭代器是否相同</div><div>iter1 != iter2      判断两个迭代器是否不相等</div></div><div>TYPE(iter)         复制迭代器（copy 构造函数）    <br><div><br></div></div>

说明

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;"><li>输出指将信息从程序传输给容器的迭代器<br></li><li>输出迭代器与输入迭代器相似,知识解除引用让程序能修改容器值,而不能读取.<br></li><li style="box-sizing: border-box;">简而言之,对于单通行,只读算法,可以使用输入迭代器;而对于单通行,只写算法,则可以使用输出迭代器.</li></ul>

正向迭代器

操作

<div>表达式                 功能表述</div><div><br></div><div>*iter               存取实际元素<br>*iter = value      将元素写入到迭代器所指位置<br></div><div>iter->member        存取实际元素的成员</div><div>++iter              向前步进（传回新位置）</div><div>iter++              向前步进（传回旧位置）</div><div>iter1 == iter2      判断两个迭代器是否相同</div><div>iter1 != iter2      判断两个迭代器是否不相等</div><div>TYPE()              产生迭代器（default构造函数）</div><div>TYPE(iter)          复制迭代器（copy构造函数）      </div>

说明

<ul><li>正向迭代器有输入/输出迭代器的全部功能<br></li><li><span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">与输入和输出迭代器不同的是,它总是按相同的顺序遍历一系列值.</span><br></li><li><span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">另外,将正向迭代器递增后,仍然可以对前面的迭代器值解除引用(如果保存了它),并可以得到相同的值.这些特征使得多次通行算法称为可能.</span><br></li></ul>

按顺序遍历？和前有什么区别？<br>可以对前面的迭代器解除引用？

双向迭代器

操作

正向迭代器

<div>表达式                 功能表述</div><div>*iter               存取实际元素</div><div>iter->member        存取实际元素的成员</div><div>++iter              向前步进（传回新位置）</div><div>iter++              向前步进（传回旧位置）</div><div>iter1 == iter2      判断两个迭代器是否相同</div><div>iter1 != iter2      判断两个迭代器是否不相等</div><div>TYPE()              产生迭代器（default构造函数）</div><div>TYPE(iter)          复制迭代器（copy构造函数） </div>

<div>--p                 前置自减迭代器</div><div>p--                 后置自减迭代器   </div>

说明

<ul><li>双向迭代器具有正向迭代器的所有特性,同时支持两种(前缀和后缀)递减运算符.<br></li></ul>

随机访问迭代器

操作

双向迭代器

<div>表达式                     功能表述</div><div>p+=i                       将迭代器递增i位</div><div>p-=i                       将迭代器递减i位</div><div>p+i                        在p位加i位后的迭代器</div><div>p-i                        在p位减i位后的迭代器</div><div>p[i]                       返回p位元素偏离i位的元素引用</div><div>p<p1                       如果迭代器p的位置在p1前，返回true，否则返回false</div><div>p<=p1                      p的位置在p1的前面或同一位置时返回true，否则返回false</div><div>p>p1                       如果迭代器p的位置在p1后，返回true，否则返回false</div><div>p>=p1                      p的位置在p1的后面或同一位置时返回true，否则返回false   </div>

说明

像a+n这样的表达式仅当a和a+n都位于容器区间(包括超尾)内时才合法.

迭代器的层次结构

<ul><li><span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">正向迭代器具有输入迭代器和输出迭代器的全部功能,同时还有自己的功能;</span><br></li><li><span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">双向迭代器具有正向迭代器的全部功能,同时还有自己的功能;</span><br></li><li><span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">随机访问迭代器具有正向迭代器的全部功能,同时还有自己的功能.</span><br></li></ul>

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;"><li style="box-sizing: border-box;">为何需要这么多迭代器呢?<br>目的是为了在编写算法尽可能使用要求最低的迭代器,并让它适用于容器的最大区间.</li></ul>

<ul><li><span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">注意,各种迭代器的类型并不是确定的,而只是一种概念性描述.//?</span><br></li><li><span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">vector<int>类的迭代器的类型为vector<int>::interator;vector迭代器是随机访问迭代器</span><br></li><li><span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">list迭代器是双向迭代器。</span><br></li></ul>

子主题

概念，改进和模型<br>（迭代器）

前言

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;"><li style="box-sizing: border-box;">STL文献使用术语概念concept来描述一系列的要求.</li><li style="box-sizing: border-box;">如果所设计的容器类需要迭代器,可考虑STL,它包含用于标准种类的迭代器模板.</li><li style="box-sizing: border-box;">概念可以具有类似继承的关系.然而,不能将C++继承机制用于迭代器.有些STL文献使用术语改进refinement来表示这种概念上的继承,因此,双向迭代器是对正向迭代器概念的一种改进.</li><li style="box-sizing: border-box;">概念的具有实现被称为模板model.</li></ul>

看不懂。。

将指针用作迭代器

原因

迭代器是广义的指针，指针满足所有迭代器的要求

应用

迭代器是STL算法的接口，而指针是迭代器。<br>因此<font color="#c41230">STL算法</font>可以使用指针来对基于指针的非STL容器进行操作。

STL算法可用于常规数组，也可用于自己设计的数组形式，<br>只要提供适当的迭代器和超尾指示器就可以了。

例子

sort()用于常规数组

const int SIZE = 100;<br>double Receipts[SIZE];<br>sort( Receipts , Receipts + SIZE );

预定义迭代器<br>//??

copy算法

作用

将数据从一个容器复制到另一个容器中。算法以迭代器方式实现。<br>可以在数组之间复制。

格式

copy( cats , cats+10 , dice.begin() );<br>

说明

前两个参数表示要复制的范围。（最好是输入迭代器）<br>最后一个参数表示要将第一个元素复制到什么位置。（最好是输出迭代器）

例子

int cats[10] = { 6,7,2,9,4,11,8,7,10,5};<br>vector<int> dice（10）;<br>copy( cast , cast + 10 ,dice.begin() );

copy会覆盖原来迭代器的内容。<br>不能使用copy()将数据放到空矢量中。vector<int>dice(10) 一定要有10；

作用

将信息复制到显示器上。把第三个参数表示输出流的迭代器。

输出流迭代器

头文件

#include<iterator.h>

模板

ostream_iterator

该模板是输出迭代器概念的一个模型，也是一个适配器——一个类或函数。

创建

声明

ostream_iterator<int,char> out_iter(cout , " " );

说明

模板参数

第一个参数

指出被发送给输出流的数据类型

第二个参数

指出了输出流使用的字符类型

构造函数参数

第一个参数

要使用输出流//可是是cout，可以是文件

第二个参数

在发送给输出流的每个数据项后显示的分隔符

例子

*out_iter++ = 15;

说明

将15由空格组成的字符串发送到cout管理的输出流中，并为下一个输出操作做好了准备。（指针+1）

相当于cout<<15<<" ";

例子

<b>//不创建命名迭代器<br>copy（dice.begin() , dice.end() , ostream_iterator<int,char>(cout," "));</b>

作用

把输入流的信息复制到数组上

输入迭代器

头文件

#include<iterator.h>

模板

ostream_iterator

创建

声明

istream_iterator<int,char> in_iter1(cin);<br>istream_iterator<int,char> in_iter2()；<br>

说明

模板参数

第一个参数

指出要读取的数据类型

第二个参数

输入流使用的字符类型

构造函数参数

使用参数cin表示由cin管理的输入流。//可以是文件

不用参数表示输入失败

例子

istream_iterator<int,char> in_iter1<int,char>(cin);<br>istream_iterator<int,char> in_iter2<int,char>()；<br><br>copy(in_iter1,in_iter2,dice.begin());</int,char></int,char>

表示代码从输入流中读取，直到文件结尾、类型不匹配或出现其他输入故障。

copy(istream_iterator <int,char>(cin),stream_iterator<int,char><int,char>()</int,char>,dice.begin());

其他有用迭代器

头文件

iterator

输出流迭代器

头文件

#include<iterator.h>

模板

ostream_iterator

该模板是输出迭代器概念的一个模型，也是一个适配器——一个类或函数。

创建

声明

ostream_iterator<int,char> out_iter(cout , " " );

说明

模板参数

第一个参数

指出被发送给输出流的数据类型

第二个参数

指出了输出流使用的字符类型

//!!!可以省略，默认和前面的相同。哪个可以省略？？不知道

构造函数参数

第一个参数

要使用输出流//可是是cout，可以是文件

第二个参数

在发送给输出流的每个数据项后显示的分隔符

例子

*out_iter++ = 15;

说明

将15由空格组成的字符串发送到cout管理的输出流中，并为下一个输出操作做好了准备。（指针+1）

相当于cout<<15<<" ";

输入流迭代器

头文件

#include<iterator.h>

模板

ostream_iterator

创建

声明

istream_iterator<int,char> in_iter1(cin);<br>istream_iterator<int,char> in_iter2()；<br>

说明

模板参数

第一个参数

指出要读取的数据类型

第二个参数

输入流使用的字符类型

构造函数参数

使用参数cin表示由cin管理的输入流。//可以是文件

不用参数表示输入失败

reverse_interator

功能

对reverse_interator执行递增会导致它被递减。

不对常规迭代器递减是为了简化对已有的函数的使用

例子

copy( dice.begin(),dice.end(),out_iter ); <br>想要反向打印dice的内容<br>copy( dice.rbegin() , dice.rend() , out_iter );

说明

 rbegin(),rend()是vector的反向迭代器

rbegin()与end()的值相同，rend()与begin()的值相同，<br>但类型不同（一个是reverse_iterator,一个iterator）

反向指针先递减，再解除引用。

int cats[10] = { 6,7,2,9,4,11,8,7,10,5};<br>vector<int> dice（10）;<br>copy( cast , cast + 10 ,dice.begin() );<br><br>vector<int>::reverse_iterator ri;<br>for ( ri = dice.rbegin() ; ri != dice.rend()； ++ri)<br>        cout<<*ri<<" ";<br>cout<<endl;

如果可以在显式声明迭代器和使用STL函数来处理内部问题；<br>eg: 上通过将rbegin()返回值传递给函数和copy()函数到显示器中；<br>选择后者，工作少，出错少

如果想创建reverse_interator迭代器怎么办？？

insert_

作用

copy（）不能自动根据发送值调整目标容器的长度，前要将dice声明包含10个元素

如果预先不知道dice的长度？或者不是覆盖，是添加到dice中怎么办？

类型

back_insert_iterator

功能

将元素插入到容器尾部

说明

只能用于允许在尾部快速插入的容器（快速插入时一个时间固定的算法）<br>eg:vector允许

front_insert_iterator

功能

元素插入到容器前端

说明

只能用于允许在起始位置做时间固定插入的容器类型，<br>vector不能满足，queue满足

insert_iterator

功能

参数指定的位置前面

说明

没有限制

可以用insert_iterator将复制数据的算法转换为插入数据的算法//??

创建

back_insert_iterator<vector<int> > back_iter( dice );

表示在dice前插入的迭代器

*back_iter=3//？？？可行吗？是不是这样已经表示在dice前已经插入了元素？是的

insert_iterator<vector<int> > insert_iter(dice , dice.begin() );

表示在dice容器的dice.begin()插入的迭代器

说明

将容器类型作为模板参数，将实际的容器标示符作为构造函数参数。

必须声明容器类型：迭代器必须使用合适的容器方法。

对insert还需要一个指示插入位置的构造函数

应用

代码

<span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">// inserts.cpp -- copy() and insert iterators</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><br></span><span class="hljs-preprocessor" style="box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">#include <iostream></span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><br></span><span class="hljs-preprocessor" style="box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">#include <string></span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><br></span><span class="hljs-preprocessor" style="box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">#include <iterator></span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><br></span><span class="hljs-preprocessor" style="box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">#include <vector></span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><br></span><span class="hljs-preprocessor" style="box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">#include <algorithm></span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><br></span><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">void</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> output(</span><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">const</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> </span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">std</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">::</span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">string</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> & s) {</span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">std</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">::</span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">cout</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> << s << </span><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">" "</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">;}<br></span><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">int</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> main()<br>{<br> </span><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">using</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> </span><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">namespace</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> </span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">std</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">;<br> </span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">string</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> s1[</span><span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">4</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">] = {</span><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">"fine"</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">, </span><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">"fish"</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">, </span><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">"fashion"</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">, </span><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">"fate"</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">};<br> </span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">string</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> s2[</span><span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">2</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">] = {</span><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">"busy"</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">, </span><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">"bats"</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">};<br> </span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">string</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> s3[</span><span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">2</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">] = {</span><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">"silly"</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">, </span><span class="hljs-string" style="color: rgb(0, 136, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">"singers"</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">};<br> </span><span class="hljs-stl_container" style="box-sizing: border-box; color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box;">vector</span><<span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box;">string</span>></span><span style="font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><font color="#333333"> </font><b><font color="#c41230">words(</font></b></span><span class="hljs-number" style="box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><b><font color="#c41230">4</font></b></span><span style="font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><b><font color="#c41230">);</font></b><font color="#333333"><br> copy(s1, s1 + </font></span><span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">4</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">, words.begin());<br> for_each(words.begin(), words.end(), output);<br> </span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">cout</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> << endl;<br><br></span><span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">// construct anonymous back_insert_iterator object</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><br> copy(s2, s2 + </span><span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">2</span><span style="font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><font color="#333333">, </font><b><font color="#c41230">back_insert_iterator<</font></b></span><span class="hljs-stl_container" style="box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><b><font color="#c41230"><span class="hljs-built_in" style="box-sizing: border-box;">vector</span><<span class="hljs-built_in" style="box-sizing: border-box;">string</span>></font></b></span><span style="font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><b><font color="#c41230"> >(words)</font><font color="#333333">);</font></b><font color="#333333"><br> for_each(words.begin(), words.end(), output);<br> </font></span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">cout</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> << endl;<br></span><span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">// construct anonymous insert_iterator object</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><br> copy(s3, s3 + </span><span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">2</span><span style="font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><font color="#333333">, </font><b><font color="#c41230">insert_iterator<</font></b></span><span class="hljs-stl_container" style="box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><b><font color="#c41230"><span class="hljs-built_in" style="box-sizing: border-box;">vector</span><<span class="hljs-built_in" style="box-sizing: border-box;">string</span>></font></b></span><span style="font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><b><font color="#c41230"> >(words, words.begin())</font></b><font color="#333333">);<br> for_each(words.begin(), words.end(), output);<br> </font></span><span class="hljs-built_in" style="color: rgb(102, 0, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">cout</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> << endl;<br> </span><span class="hljs-comment" style="color: rgb(136, 0, 0); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">// cin.get();</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"><br> </span><span class="hljs-keyword" style="color: rgb(0, 0, 136); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">return</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);"> </span><span class="hljs-number" style="color: rgb(0, 102, 102); box-sizing: border-box; font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">0</span><span style="color: rgb(51, 51, 51); font-family: 'Source Code Pro', monospace; line-height: 13.5333px; white-space: pre; background-color: rgba(128, 128, 128, 0.0470588);">; <br>}</span>

结果

fine fish fashion fate<br>fine fish fashion fate busy bats<br>silly singers fine fish fashion fate busy bats

说明

都是输出容器概念的模型

容器

容器概念

含义

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;"><li style="box-sizing: border-box;">容器概念指定了所有STL容器类都必须满足的一系列要求.</li></ul>

特点

容器是存储其他对象的对象。被存储的对象必须是同一种类型的

<span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">存储在容器中的数据为容器所有,这意味着当容器过期时,存储在容器中的数据也将过期<br>(然而,如果数据是指针的化,则它指向的数据并不一定过期).</span><br>

存储再容器中的对象的<br>要求

不能将任何类型的对象存储在容器中,具体地说,类型必须是可复制构造的和可赋值的.<br>基本类型满足这些要求;<br>只要类定义没有将复制构造函数和赋值运算符声明为私有或保护的,则也满足这种要求<br><span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; font-size: 14px; line-height: 26px;">C++改进了这些概念,添加了术语可复制插入copyInsertable和可移动插入MoveInsertable.//??</span><br>

<span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;">一些基本的容器特征<br>（几乎所有容器都有的）<br>（通用特征）</span>

表格总结

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; line-height: 26px;"><li style="box-sizing: border-box;">其中,X表示容器类型,a和b表示类型为X的值;r表示类型为X&的值;u表示类型为X的标识符.</li><li style="box-sizing: border-box;"><table style="box-sizing: border-box; width: 906.4px; border-collapse: collapse; border-spacing: 0px; border: 1px solid rgb(238, 238, 238); background-color: transparent;"><thead style="box-sizing: border-box;"><tr style="box-sizing: border-box;"><th style="box-sizing: border-box; border-color: rgb(238, 238, 238);">表达式</th><th style="box-sizing: border-box; border-color: rgb(238, 238, 238);">返回类型</th><th style="box-sizing: border-box; border-color: rgb(238, 238, 238);">说明</th><th style="box-sizing: border-box; border-color: rgb(238, 238, 238);">复杂度</th></tr></thead><tbody style="box-sizing: border-box;"><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X::iterator</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">指向T的迭代器类型</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">满足正向迭代器要求的任何迭代器</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">编译时间</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X::value_type</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">T</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">T的类型</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">编译时间</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X u;</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);"></td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">创建一个名为u的空容器</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">固定</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X();</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);"></td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">创建一个匿名的空容器</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">固定</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X u(a);</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);"></td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">调用复制构造函数后u==a</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">线性</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X u=a;</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);"></td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">作用同X u(a);</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">线性</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">r=a;</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X&</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">调用赋值运算符后r==a</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">线性</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">(&a)->~X();</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">void</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">对容器中每个元素应用析构函数</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">线性</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">a.begin()</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">迭代器</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">返回指向容器第一个元素的迭代器</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">固定</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">a.end()</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">迭代器</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">返回超尾值迭代器</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">固定</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">a.size()</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">无符号整型</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">返回元素个数,等价于a.end()-a.begin()</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">固定</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">a.swap(b)</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">void</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">交换a和b的内容</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">固定</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">a==b</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">可转换为bool</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">如果a和b的长度相同,且a中每个元素都等于(==为真)b中相应的元素,则为帧</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">线性</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">a!=b</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">可转换bool</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">返回!(a==b)</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">线性<br><br></td></tr></tbody></table></li></ul>

表格内容详解

X::iterator 

创建X的迭代器

vector<int>::iterator t1;

迭代器的作用见上

X::value_type

创建以容器存储的数据类型的变量/对象

<div><span style="font-size: 14px;"><span style="font-family: Arial;"><span style="color: rgb(51, 51, 51);">vector<C> vec;  //假设C是自定义类型</span></span></span></div><div><span style="font-size: 14px;"><span style="font-family: Arial;"><span style="color: rgb(51, 51, 51);">vector<C>::value_type x;</span></span></span></div><div style="color: rgb(51, 51, 51); font-family: Arial; font-size: 14px;">那么第二句定义的变量x的数据类型是C。</div>

<div><span style="font-size: 14px;"><span style="font-family: Arial;"><span style="color: rgb(51, 51, 51);">vector<int> vec;</span></span></span></div><div style="color: rgb(51, 51, 51); font-family: Arial; font-size: 14px;">vector<int>::value_type x;<br>//x的数据类型是int</div>

X u

vector<int> vec;

X()

vector<int>()

应用？？

X u(a)

vector<int> vec(tmp); //声明并用tmp向量初始化vec向量

X u=a

=上

r=a

<div>....<br>vector<int> vec1(arr,arr+5);</div><div>vector<int>vec2;</div><div>vec2=vec1;</div>

容器之间的赋值。

（&a）->~X();

vector<int> vec1;<br>( &vec1 )->vector<int>();

迭代器

a.begin()

a.end()

a.size()

a.swap()

vector<int> a;<br>...<br>vector<int> b:<br>....<br><br>a.swap(b);<br>//a,b容器交换

a==b

判断两个容器是否相等，是返回true

a！=b

判断两个容器是否不相等

C++11新增的容器要求

表格

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; font-size: 14px; line-height: 26px;"><li style="box-sizing: border-box;">表16.6 C++11新增的基本容器要求,在这个表中,rv表示类型为X的非常量右值,如函数的返回值.//右值？有区别吗？</li><li style="box-sizing: border-box;"><table style="box-sizing: border-box; width: 866.4px; border-collapse: collapse; border-spacing: 0px; border: 1px solid rgb(238, 238, 238); background-color: transparent;"><thead style="box-sizing: border-box;"><tr style="box-sizing: border-box;"><th style="box-sizing: border-box; border-color: rgb(238, 238, 238);">表达式</th><th style="box-sizing: border-box; border-color: rgb(238, 238, 238);">返回类型</th><th style="box-sizing: border-box; border-color: rgb(238, 238, 238);">说明</th><th style="box-sizing: border-box; border-color: rgb(238, 238, 238);">复杂度</th></tr></thead><tbody style="box-sizing: border-box;"><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X u(rv);</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);"></td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">调用移动构造函数后,u的值与rv的原始值相同</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">线性</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X u=rv;</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);"></td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">作用同Xu(rv);</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);"></td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">a=rv;</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">X&</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">调用移动赋值运算符后,u的值与rv的原始值相同</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">线性</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">a.cbegin()</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">const_iterator</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">返回指向容器第一个元素的const迭代器</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">固定</td></tr><tr style="box-sizing: border-box;"><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">a.cend</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">const_iterator</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">返回超尾值const迭代器</td><td style="box-sizing: border-box; padding: 8px; line-height: 20px; vertical-align: top; border: 1px solid rgb(238, 238, 238);">固定</td></tr></tbody></table></li></ul>

说明

移动构造、移动赋值函数（印象笔记中有）

复制构造和复制赋值以及移动构造移动赋值的区别在于:<br>复制操作保留源对象，<br>而移动操作可修改源对象（因此不能用const）,还可能转让所有权，不做任何复制。<br>如果源对象是临时的，移动操作的效率将高于常规复制。

复杂度

含义

描述执行操作所需要的时间

从快到慢

编译时间

操作将在编译时执行，执行时间为0

固定时间

操作发生在运行阶段，但独立于对象中的元素数目

例子

有一个装满礼物的狭长盒子，包裹一字排开。只打开一端。<br>从打开一端取出一个礼物，这是固定时间的任务。<br>无论打开一端后面有10个还是1000个礼物，都没有区别。

线性时间

时间与元素数目成正比

例子

有一个装满礼物的狭长盒子，包裹一字排开。只打开一端。<br>拿出最末尾的礼物，时间与拿出礼物的数目相关。

如果a和b都是容器,则a==b具有线性复杂度,因为==操作必须用于容器中的每个元素.

其他

<ul style="box-sizing: border-box; color: rgb(0, 0, 0); font-family: 'microsoft yahei'; font-size: 14px; line-height: 26px;"><li style="box-sizing: border-box;">复杂度要求是STL特征,虽然实现细节可以隐藏,但性能规格应公开,以便程序员能够指导完成特定操作的计算成本.</li></ul>

种类

序列

概念

序列概念增加了迭代器至少是正向迭代器这样的要求,<br>这保证了元素将按特定顺序排列,不会在两次迭代之间发生变化.

要求元素按严格的线性顺序排列。数组、链表都是序列，分支结构（类似于树）不是。

种类

vector、deque、list、forward_list(C++11)、queue、priority_queue()、stack、array（C++11）

基本操作

其他一定要完成的操作

关联容器

种类

set、multiset、map、multimap

序列

vector

优点

vector是数组的一种类表示,它提供了自动内存管理功能,可以动态地改变vector对象的长度,<br>并随着元素的添加和删除而增大和缩小

<span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; font-size: 14px; line-height: 26px;">.它提供了对元素的随机访问.</span><br>

在尾部添加和删除元素的时间是固定的,但在头部或中间插入和删除元素的复杂度为线性时间.

<span style="color: rgb(0, 0, 0); font-family: 'microsoft yahei'; font-size: 14px; line-height: 26px;">除序列外,vector还是可反转容器reversible container概念的模型.</span><br>

....

印象笔记中

关联容器

简介

特点

关键容器将值与键关联在一起，并使用键来查找值。

表达式 X::value_type指出了存储在容器中得值的类型。<br>X：：value_tyoe指出了键的类型。

优点

提供对元素的快速访问。

关联容器允许插入新的元素，但不能指定元素的插入位置。

关联容器有用于确定数据放置位置的算法，以便能够快速检索信息。

实现方式

某种树实现

类型

set、multiset、map、multimap

前两种头文件set.h,(以前分别  set.h和multiset,h )后两种map.h

函数对象<br>/函数符

内容

函数名、指向函数的指针、重载了（）运算符的类对象

重载了（）运算符的类对象

<div>class Linear</div><div>{</div><div>private:</div><div><span> </span>double slope;</div><div><span> </span>double y0;</div><div>public:</div><div><span> </span>Linear(double s1_=1,double y_=0)</div><div><span> </span>:slope(s1_),y0(y_){}</div><div><span> </span>double operator()(double x){ return y0+slope*x;}</div><div>}</div><div><br></div><div>Linear f1;</div><div>Linear f2(2.5,10.0);</div><div>double y1 = f1(12.5);</div><div>double y2 = f2(0.4);</div>

分类

<ul><li>生成器generator是不用参数就可以调用的函数符.</li><li>一元函数unary function是用一个参数可以调用的函数符</li><li>二元函数binary function是用两个参数可以调用的函数符.</li><li>当然,这些概念都有相应的改进版: <br><ul><li>返回bool值的一元函数是谓词</li><li>返回bool值的二元函数是二元谓词</li></ul></li></ul>

图像

将接受两个参数的模板函数，<br>转换为单个参数的函数对象

格式

<div>template<class T></div><div>bool toobig(const T&val,const T & lim)</div><div>{</div><div><span> </span>return val>lim;</div><div>}</div>

<div>template<class T></div><div>class TooBig2</div><div>{</div><div>private:</div><div><span> </span>T cutoff;</div><div>public:</div><div><span> </span>TooBig2(const T &t):cutoff(t){}</div><div><span> </span>bool operator()(const T & v){return tooBig<T>(v,cutoff);}<span> </span></div><div>};</div><div><br></div><div>yadayada.remove_if(f100);</div><div>yadayada.remove_if(TooBig<int>(200));</div><div><br></div>

应用代码

代码

<div>// functor.cpp -- using a functor</div><div>#include <iostream></div><div>#include <list></div><div>#include <iterator></div><div>#include <algorithm></div><div><br></div><div>template<class T>  // functor class defines operator()()</div><div>class TooBig</div><div>{</div><div>private:</div><div>    T cutoff;</div><div>public:</div><div>    TooBig(const T & t) : cutoff(t) {}</div><div>    bool operator()(const T & v) { return v > cutoff; }</div><div>};</div><div><br></div><div>void outint(int n) {std::cout << n << " ";}</div><div><br></div><div>int main()</div><div>{</div><div>    using std::list;</div><div>    using std::cout;</div><div>    using std::endl;</div><div><span> </span>using std::for_each;</div><div><span> </span>using std::remove_if;</div><div><br></div><div>    TooBig<int> f100(100); // limit = 100</div><div>    int vals[10] = {50, 100, 90, 180, 60, 210, 415, 88, 188, 201};</div><div>    list<int> yadayada(vals, vals + 10); // range constructor</div><div>    list<int> etcetera(vals, vals + 10);</div><div> </div><div> // C++11 can use the following instead</div><div>//  list<int> yadayada = {50, 100, 90, 180, 60, 210, 415, 88, 188, 201};</div><div>//  list<int> etcetera {50, 100, 90, 180, 60, 210, 415, 88, 188, 201};</div><div><br></div><div>    cout << "Original lists:\n";</div><div>    for_each(yadayada.begin(), yadayada.end(), outint);</div><div>    cout << endl;</div><div>    for_each(etcetera.begin(), etcetera.end(), outint);</div><div>    cout << endl;</div><div>    yadayada.remove_if(f100);               // use a named function object</div><div>    etcetera.remove_if(TooBig<int>(200));   // construct a function object</div><div>    cout <<"Trimmed lists:\n";</div><div>    for_each(yadayada.begin(), yadayada.end(), outint);</div><div>    cout << endl;</div><div>    for_each(etcetera.begin(), etcetera.end(), outint);</div><div>    cout << endl;</div><div>    // std::cin.get();</div><div>    return 0;</div><div>}<br><br>结果：<br><div>Original lists:</div><div>50 100 90 180 60 210 415 88 188 201</div><div>50 100 90 180 60 210 415 88 188 201</div><div>Trimmed lists:</div><div>50 100 90 60 88</div><div>50 100 90 180 60 88 188</div></div>

子主题