C++泛型算法1——初识泛型算法

什么是泛型算法

顺序容器只定义了很少的操作：在多数情况下，我们可以添加和删除元素、访问首尾元素、确定容器是否为空以及获得指向首元素或尾元素之后位置的迭代器。

我们可以想象用户可能还希望做其他很多有用的操作：查找特定元素、替换或删除一个特定值、重排元素顺序等。

标准库并未给每个容器都定义成员函数来实现这些操作，而是定义了一组泛型算法(generic algorithm）：

1. 称它们为“算法”，是因为它们实现了一些经典算法的公共接口，如排序和搜索；
2. 称它们是“泛型的”，是因为它们可以用于不同类型的元素和多种容器类型（不仅包括标准库类型，如vector或1ist，还包括内置的数组类型），以及我们将看到的，还能用于其他类型的序列。

概述

大多数算法都定义在头文件algorithm 中。标准库还在头文件 numeric中定义了以组数值泛型算法。

一般情况下，这些算法并不直接操作容器，而是遍历由两个迭代器指定的一个元素范围来进行操作。

通常情况下，算法遍历范围，对其中每个元素进行一些处理。

例如，假定我们有一个int的vector，希望知道vector中是否包含一个特定值。回答这个问题最方便的方法是调用标准库算法 find:

	int val = 42;//我们将查找的值
		//如果在vec中找到想要的元素，则返回结果指向它，否则返回结果为vec.cend（)
		auto result = find(vec.cbegin(), vec.cend(), val);
	//报告结果
	cout << "The value " << val
		<< (result == vec.cend()?" is not present" :" is present") << endl;

传递给find的前两个参数是表示元素范围的迭代器，第三个参数是一个值。

find将范围中每个元素与给定值进行比较。

它返回指向第一个等于给定值的元素的迭代器。

如果范围中无匹配元素，则find返回第二个参数来表示搜索失败。因此，我们可以通过比较返回值和第二个参数来判断拽索是否成功。

我们在输出语句中执行这个检测，其中使用了条件运算符来报告搜索是否成功。

由于find操作的是迭代器，因此我们可以用同样的find函数在任何容器中查找值。

例如，可以用find在一个string的list中查找一个给定值：

string val="a value"；//我们要查找的值
// 此调用在list中查找string元素
auto result = find(1st,cbegin(), lst.cend(), val);

类似的，由于指针就像内置数组上的迭代器一样，我们可以用find在数组中查找值；

int ia[] ={27,210, 12,47,109,83};
int val = 83;
int* result = find(begin(ia),end(ia),val);

此例中我们使用了标准库begin和end函数来获得指向ia中首元素和尾元素之后位置的指针，并传递给find。

还可以在序列的子范围中查找，只需将指向子范围首元素和尾元素之后位置的迭代器（指针）传递给find。

例如，下面的语句在ia[1]、ia[2]和ia[3]中查找给定元素：

//在从ia[1]开始，直至（但不包含）ia[4]的范围内查找元素
auto result = find(ia + 1, ia + 4, val);

算法如何工作

为了弄清这些算法如何用于不同类型的容器，让我们更近地观察一下 find。find
的工作是在一个未排序的元素序列中查找一个特定元素。概念上，find应执行如下步骤：

1. 访问序列中的首元素。
2. 比较此元素与我们要查找的值。
3. 如果此元素与我们要查找的值匹配，find返回标识此元素的值。
4. 否则，find前进到下一个元素，重复执行步骤2和3。
5. 如果到达序列尾，find应停止。
6. 如果find 到达序列末尾，它应该返回一个指出元素未找到的值。此值和步骤3返回的值必须具有相容的类型。

这些步骤都不依赖于容器所保存的元素类型。

因此，只要有一个迭代器可用来访问元素，find就完全不依赖于容器类型（甚至无须理会保存元素的是不是容器）。

迭代器令算法不依赖于容器，……

在上述find函数流程中，除了第2步外，其他步骤都可以用迭代器操作来实现：

• 利用迭代器解引用运算符可以实现元素访问；
• 如果发现匹配元素，find可以返回指向该元素的迭代器；
• 用迭代器递增运算符可以移动到下一个元素；
• 尾后迭代器可以用来判断 find是否到达给定序列的末尾；
• find可以返回尾后迭代器来表示未找到给定元素。

……，但算法依赖于元素类型的操作

虽然迭代器的使用令算法不依赖于容器类型，但大多数算法都使用了一个（或多个）元素类型上的操作。

例如，在步骤2中，find用元素类型的一运算符完成每个元素与给定值的比较。其他算法可能要求元素类型支持< 运算符。不过，我们将会看到，大多数算法提供了一种方法，允许我们使用自定义的操作来代替默认的运算符。

关键概念：算法永远不会执行容器的操作

泛型算法本身不会执行容器的操作，它们只会运行于迭代器之上，执行迭代器的操作。泛型算法运行于迭代器之上而不会执行容器操作的特性带来了一个令人惊讶但非常必要的编程假定：算法永远不会改变底层容器的大小。算法可能改变容器中保存的元素的值，也可能在容器内移动元素，但永远不会直接添加或删除元素.

如我们将在所看到的，标准库定义了一类特殊的迭代器，称为插入器（inserter）。与普通迭代器只能遍历所绑定的容器相比，插入器能做更多的事情。当给这类迭代器赋值时，它们会在底层的容器上执行插入操作。因此，当一个算法操作一个这样的迭代器时，迭代器可以完成向容器添加元素的效果，但算法自身永远不会做这样的操作。

初识泛型算法

标准库提供了超过100个算法。

幸运的是，与容器类似，这些算法有一致的结构。

比起死记硬背全部100多个算法，理解此结构可以帮助我们更容易地学习和使用这些算法。

在本文中，我们将展示如何使用这些算法，并介绍刻画了这些算法的统一原则。

除了少数例外，标准库算法都对一个范围内的元素进行操作。我们将此元素范围称为“输入范围”。接受输入范围的算法总是使用前两个参数来表示此范围，两个参数分别是指向要处理的第一个元素和尾元素之后位置的迭代器。

虽然大多数算法遍历输入范围的方式相似，但它们使用范围中元素的方式不同。理解算法的最基本的方法就是了解它们是否读取元素、改变元素或是重排元素顺序。

只读算法

一些算法只会读取其输入范围内的元素，而从不改变元素。

• find就是这样一种算法,
• 另一个只读算法是accumulate，它定义在头文件numeric中。

accumulate函数接受三个参数，前两个指出了需要求和的元素的范围，第三个参数是和的初值。

假定vece是一个整数序列，则:

//对vec中的元素求和，和的初值是0
int sum = accumulate(vec.cbegin(), vec.cend(), 0);

这条语句将sum设置为vee中元素的和，和的初值被设置为0。

accumulate的第三个参数的类型决定了函数中使用哪个加法运算符以及返回值的类型。

算法和元素类型

accumulate将第三个参数作为求和起点，这蕴含着一个编程假定：将元素类型加到和的类型上的操作必须是可行的。

即，序列中元素的类型必须与第三个参数匹配，或者能够转换为第三个参数的类型。

在上例中，vec中的元素可以是int，或者是double、long 1ong 或任何其他可以加到int上的类型。

下面是另一个例子，由于string 定义了+运算符，所以我们可以通过调用accumulate 来将vector中所有string元素连接起来：

string sum = accumulate(v.cbegin()， v.cend()，string(""));

此调用将v中每个元素连接到一个string上，该string初始时为空串。注意，我们通过第三个参数显式地创建了一个string。将空串当做一个字符串字面值传递给第三个参数是不可以的，会导致一个编译错误。

//错误：const char*上没有定义+运算符
string sum = accumulate(v.cbegin(), v.cend()，"");

原因在于，如果我们传递了一个字符串字面值，用于保存和的对象的类型将是const char*如前所述，此类型决定了使用哪个+运算符。由于const char*并没有+运算符，此调用将产生编译错误。

对于只读取而不改变元素的算法，通常最好使用cbegin（)和cend(）。但是，如果你计划使用算法返回的迭代器来改变元素的值，就需要使用begin()和end()的结果作为参数。

操作两个序列的算法

另一个只读算法是equal，用于确定两个序列是否保存相同的值。

它将第一个序列中的每个元素与第二个序列中的对应元素进行比较。

如果所有对应元素都相等，则返回true，否则返回false。

此算法接受三个迭代器：前两个（与以往一样）表示第一个序列中的元素范围，第三个表示第二个序列的首元素：

// roster2中的元素数目应该至少与roster1一样多
equal(rosterl.cbegin(), rosterl.cend(), roster2.cbegin());

由于equal利用迭代器完成操作，因此我们可以通过调用equal来比较两个不同类型的容器中的元素。而且，元素类型也不必一样，只要我们能用一来比较两个元素类型即可。

例如，在此例中，rosterl可以是 vector<string>，而 roster2是 list<const char*>。

但是，equal基于一个非常重要的假设：它假定第二个序列至少与第一个序列一样长。此算法要处理第一个序列中的每个元素，它假定每个元素在第二个序列中都有一个与之对应的元素。

那些只接受一个单一迭代器来表示第二个序列的算法，都假定第二个序列至少与第一个序列一样长。

写容器元素的算法

一些算法将新值赋予序列中的元素。当我们使用这类算法时，必须注意确保序列原大小至少不小于我们要求算法写入的元素数目。

记住，算法不会执行容器操作，因此它们自身不可能改变容器的大小。

一些算法会自己向输入范围写入元素。这些算法本质上并不危险，它们最多写入与给定序列一样多的元素。

例如，算法fill接受一对迭代器表示一个范围，还接受一个值作为第三个参数。fill将给定的这个值赋予输入序列中的每个元素。

fill(vec.begin()，vec.end()，0）；//将每个元素重置为0
//将容器的一个子序列设置为10
Fill(vec.begin0), vec.begin() + vec.size()/2, 10);

由于fill向给定输入序列中写入数据，因此，只要我们传递了一个有效的输入序列，写入操作就是安全的。

关键概念：迭代器参数

一些算法从两个序列中读取元素。构成这两个序列的元素可以来自于不同类型的容器例如，第一个序列可能保存于一个vector中，而第二个序列可能保存于一个list、deque、内置数组或其他容器中。而且，两个序列中元素的类型也不要求严格匹配言算法要求的只是能够比较两个序列中的元素。例如，对 equal 算法，元素类型不要求相同，但是我们必须能使用——来比较来自两个序列中的元素。

操作两个序列的算法之间的区别在于我们如何传递第二个序列。一些算法，例如equal，接受三个迭代器：前两个表示第一个序列的范围，第三个表示第二个序列中的首元素。其他算法接受四个迭代器：前两个表示第一个序列的元素范围，后两个表示第二个序列的范围。

用一个单一迭代器表示第二个序列的算法都假定第二个序列至少与第一个一样长。确保算法不会试图访问第二个序列中不存在的元素是程序员的责任。例如，算法equal会将其第一个序列中的每个元素与第二个序列中的对应元素进行比较。如果第二个序列是第一个序列的一个子集，则程序会产生一个严重错误——equal会试图访问第二个序列中末尾之后（不存在）的元素。

算法不检查写操作

一些算法接受一个迭代器来指出一个单独的目的位置。这些算法将新值赋予一个序列中的元素，该序列从目的位置迭代器指向的元素开始。

例如，函数 fill_n接受一个单迭代器、一个计数值和一个值。它将给定值赋予迭代器指向的元素开始的指定个元素。我们可以用fill_n将一个新值赋予vector中的元素：

vector<int> vec; // 空vector
//使用vec，赋予它不同值
fill_n(vec.begin(), vec.size(),0);//将所有元素重置为0

函数fill_n假定写入指定个元素是安全的.

即，如下形式的调用

fill_n(dest， n, val)

fill_n假定dest 指向一个元素，而从dest开始的序列至少包含n个元素。
 

一个初学者非常容易犯的错误是在一个空容器上调用fill_n（或类似的写元素的算法）：

vector<int> vec;// 空向量
//灾难：修改 vec中的10个（不存在）元素
fill_n(vec.begin(),10, 0);

这个调用是一场灾难。我们指定了要写入10个元素，但vec中并没有元素——它是空的。这条语句的结果是未定义的。

向目的位置迭代器写入数据的算法假定目的位置足够大，能容纳要写入的元素。

介绍 back_inserter

一种保证算法有足够元素空间来容纳输出数据的方法是使用插入迭代器（inser iterator）。

插入迭代器是一种向容器中添加元素的迭代器。

通常情况，当我们通过一个迭代器向容器元素赋值时，值被赋予迭代器指向的元素。而当我们通过一个插入迭代器赋值时，一个与赋值号右侧值相等的元素被添加到容器中。

但是，为了展示如何用算法向容器写入数据，我们现在将使用back_inserter,它是定义在头文件iterator中的一个函数。

back_inserter接受一个指向容器的引用，返回一个与该容器绑定的插入迭代器。当我们通过此迭代器赋值时，赋值运算符会调用push_back将一个具有给定值的元素添加到容器中：

vector<int> vec；//空向量
auto it =back_inserter(vec);//通过它赋值会将元素添加到vec中
*it=42；//vec中现在有一个元素，值为42

我们常常使用back_inserter来创建一个迭代器，作为算法的目的位置来使用。例如：

vector<int> vec；//空向量
//正确：backinserter创建一个插入迭代器，可用来向vec添加元素
fill_n(back_inserter(vec)，10，0);//添加10个元素到vec

在每步迭代中，fill_n向给定序列的一个元素赋值。由于我们传递的参数是back_inserter返回的迭代器，因此每次赋值都会在vec上调用push_back。最终，这条fill_n调用语句向vec的末尾添加了10个元素，每个元素的值都是0.

拷贝算法

拷贝（copy）算法是另一个向目的位置迭代器指向的输出序列中的元素写入数据的算法。

此算法接受三个迭代器，前两个表示一个输入范围，第三个表示目的序列的起始位置。

此算法将输入范围中的元素拷贝到目的序列中。传递给copy的目的序列至少要包含与输入序列一样多的元素，这一点很重要。

我们可以用copy实现内置数组的拷贝，如下面代码所示：

int al[]=(0,1,2,3,4,5,6,7,8,9);
int a2[sizeof(al)/sizeof(*al)]；// a2与al大小一样
// ret 指向拷贝到a2的尾元素之后的位置
auto ret = copy(begin(al), end(al)，a2);//把a1的内容拷贝给a2

此例中我们定义了一个名为a2的数组，并使用sizeof确保a2与数组a1包含同样多的元素。接下来我们调用copy完成从a1到a2的拷贝。在调用copy后，两个数组中的元素具有相同的值。

copy返回的是其目的位置迭代器（递增后）的值。即，ret恰好指向拷贝到a2的尾元素之后的位置。

多个算法都提供所谓的“拷贝”版本。这些算法计算新元素的值，但不会将它们放置在输入序列的末尾，而是创建一个新序列保存这些结果。

例如，replace算法读入一个序列，并将其中所有等于给定值的元素都改为另一个值。此算法接受4个参数：前两个是迭代器，表示输入序列，后两个一个是要搜索的值,另一个是新值。它将所有等于第一个值的元素替换为第二个值：

//将所有值为0的元素改为42
replace (ilst.begin(), ilst.end(), 0, 42);

此调用将序列中所有的0都替换为42。如果我们希望保留原序列不变，可以调用replace_copyo此算法接受额外第三个迭代器参数，指出调整后序列的保存位置：

//使用back_inserter按需要增长目标序列
replace_copy(ilst.cbegin(),ilst.cend(),back_inserter(ivec),0,42);

此调用后，ilst并未改变，ivec包含ilst的一份拷贝，不过原来在ilst中值为0的元素在ivec中都变为42。

重排容器元素的算法

某些算法会重排容器中元素的顺序，一个明显的例子是sort。

调用sort 会重排输入序列中的元素，使之有序，它是利用元素类型的<运算符来实现排序的。

例如，假定我们想分析一系列儿童故事中所用的词汇。假定已有一个vector，保存了多个故事的文本。我们希望化简这个vector，使得每个单词只出现一次，而不管单词在任意给定文档中到底出现了多少次。

为了便于说明问题，我们将使用下面简单的故事作为输入:

给定此输入，我们的程序应该生成如下vector：

为了消除重复单词，首先将vector排序，使得重复的单词都相邻出现。

一旦vector排序完毕，我们就可以使用另一个称为unique的标准库算法来重排vector，使得不重复的元素出现在vector的开始部分。由于算法不能执行容器的操作，我们将使用vector的erase成员来完成真正的删除操作：

void elimDups(vector<string> &words)
{
//按字典序排序words，以便查找重复单词
sort(words.begin(), words.end());

// unique重排输入范围，使得每个单词只出现一次
//排列在范围的前部，返回指向不重复区域之后一个位置的迭代器

auto end unique = unique(words.begin(), words.end());

// 使用向量操作erase删除重复单词
words.erase(end_unique, words.end());
}

sort 算法接受两个迭代器，表示要排序的元素范围。在此例中，我们排序整个vector。完成 sort后，words的顺序如下所示：

注意，单词red和the各出现了两次。

使用unique

words 排序完毕后，我们希望将每个单词都只保存一次。

unique算法重排输入序列,将相邻的重复项“消除”，并返回一个指向不重复值范围末尾的迭代器。调用unique后，vector将变为：

words的大小并未改变，它仍有10个元素。但这些元素的顺序被改变了——相邻的重复元素被“删除”了。我们将删除打引号是因为unique并不真的删除任何元素，它只是覆盖相邻的重复元素，使得不重复元素出现在序列开始部分。unique 返回的迭代器指向最后一个不重复元素之后的位置。此位置之后的元素仍然存在，但我们不知道它们的值是什么。

标准库算法对迭代器而不是容器进行操作。因此，算法不能（直接）添加或删除元素。

使用容器操作删除元素

为了真正地删除无用元素，我们必须使用容器操作，本例中使用erase。

我们删除从end_unique开始直至words末尾的范围内的所有元素。

这个调用之后，words包含来自输入的8个不重复的单词。

值得注意的是，即使words中没有重复单词，这样调用erase也是安全的。

在此情况下，unique会返回words.end(）。

因此，传递给erase的两个参数具有相同的值：words.end()。

迭代器相等意味着传递给erase的元素范围为空。删除一个空范围没有什么不良后果，因此程序即使在输入中无重复元素的情况下也是正确的。