10-非修改式序列操作

G.5.1　非修改式序列操作

表G.13对非修改式序列操作进行了总结。这里没有列出参数，而重载函数只列出了一次。表后做了更详细的说明，其中包括原型。因此，可以浏览该表，以了解函数的功能，如果对某个函数非常感兴趣，则可以了解其细节。

表G.13　非修改式序列操作

| 函数 | 描述 | | :----- | :----- | :----- | :----- | | all_of() | 如果对于所有元素的谓词测试都为true，则返回true。这是C++11新增的 | | any_of() | 只要对于任何一个元素的谓词测试为true，就返回true。这是C++11新增的 | | none_of() | 如果对于所有元素的谓词测试都为false，则返回true。这是C++11新增的 | | for_each() | 将一个非修改式函数对象用于区间中的每个成员 | | find() | 在区间中查找某个值首次出现的位置 | | find_if() | 在区间中查找第一个满足谓词测试条件的值 | | find_if_not() | 在区间中查找第一个不满足谓词测试条件的值。这是C++11新增的 | | find_end() | 在序列中查找最后一个与另一个序列匹配的值。匹配时可以使用等式或二元谓词 | | find_first_of() | 在第二个序列中查找第一个与第一个序列的值匹配的元素。匹配时可以使用等式或二元谓词 | | adjacent_find | 查找第一个与其后面的元素匹配的元素。匹配时可以使用等式或二元谓词 | | count() | 返回特定值在区间中出现的次数 | | count_if() | 返回特定值与区间中的值匹配的次数，匹配时使用二元谓词 | | mismatch() | 查找区间中第一个与另一个区间中对应元素不匹配的元素，并返回指向这两个元素的迭代器。匹配时可以使用等式或二元谓词 | | equal() | 如果一个区间中的每个元素都与另一个区间中的相应元素匹配，则返回true。匹配时可以使用等式或二元谓词 | | is_permutation() | 如果可通过重新排列第二个区间，使得第一个区间和第二个区间对应的元素都匹配，则返回true，否则返回false。匹配可以是相等，也可以使用二元谓词进行判断。这是C++11新增的 | | search() | 在序列中查找第一个与另一个序列的值匹配的值。匹配时可以使用等式或二元谓词 | | search_n() | 查找第一个由n个元素组成的序列，其中每个元素都与给定值匹配。匹配时可以使用等式或二元谓词 |

下面更详细地讨论这些非修改型序列操作。对于每个函数，首先列出其原型，然后做简要地描述。和前面一样，迭代器对指出了区间，而选择的模板参数名指出了迭代器的类型。通常，[first, last]区间指的是从first到last（不包括last）。有些函数接受两个区间，这两个区间的容器类型可以不同。例如，可以使用equal()来对链表和矢量进行比较。作为参数传递的函数是函数对象，这些函数对象可以是指针（如函数名），也可以是定义了()操作的对象。正如第16章介绍的，谓词是接受一个参数的布尔函数，二元谓词是接受2个参数的布尔函数（函数可以不是bool类型，只要它对于false返回0，对于true返回非0值）。

1．all_of()（C++11）

template<class InputIterator, class Predicate>
bool all_of(InputIterator first, InputIterator last,
            Predicate pred);

如果对于区间[first, last]中的每个迭代器，pred(*i)都为true，或者该区间为空，则函数all_of()返回true；否则返回false。

2．any_of()（C++11）

template<class InputIterator, class Predicate>
bool any_of(InputIterator first, InputIterator last,
            Predicate pred);

如果对于区间[first, last]中的每个迭代器，pred(*i)都为false，或者该区间为空，则函数any_of()返回false；否则返回true。

3．none_of()（C++11）

template<class InputIterator, class Predicate>
bool none_of(InputIterator first, InputIterator last,
             Predicate pred);

如果对于区间[first, last]中的每个迭代器，pred(*i)都为false，或者该区间为空，则函数all_of()返回true；否则返回false。

4．for_each()

template<class InputIterator, class Function>
Function for_each(InputIterator first, InputIterator last,
                  Function f);

for_each()函数将函数对象f用于[first, last]区间中的每个元素，它也返回f。

5．find()

template<class InputIterator, class T>
InputIterator find(InputIterator first, InputIterator last,
                   const T& value);

find()函数返回一个迭代器，该迭代器指向区间[first, last]中第一个值为value的元素；如果没有找到这样的元素，则返回last。

6．find_if()

template<class InputIterator, class Predicate>
InputIterator find_if(InputIterator first, InputIterator last,
                      Predicate pred);

find_if()函数返一个迭代器，该迭代器指向[first, last]区间中第一个对其调用函数对象pred(*i)时结果为true的元素；如果没有找到这样的元素，则返回last。

7．find_if_not()

template<class InputIterator, class Predicate>
InputIterator find_if_not(InputIterator first, InputIterator last,
                      Predicate pred);

find_if_not()函数返一个迭代器，该迭代器指向[first, last]区间中第一个对其调用函数对象pred(*i)时结果为false的元素；如果没有找到这样的元素，则返回last。

8．find_end()

template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_end(
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2,
    class BinaryPredicate>
ForwardIterator1 find_end(
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2,
         BinaryPredicate pred);

find_end()函数返回一个迭代器，该迭代器指向[first1, last1] 区间中最后一个与[first2, last2] 区间的内容匹配的序列的第一个元素。第一个版本使用值类型的= =运算符来比较元素；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(it1, it2)为true，则it1和it2指向的元素匹配。如果没有找到这样的元素，则它们都返回last1。

9．find_first_of()

template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 find_first_of(
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2,
         class BinaryPredicate>
ForwardIterator1 find_first_of(
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2,
         BinaryPredicate pred);

find_first_of() 函数返回一个迭代器，该迭代器指向区间[first1, last1]中第一个与[first2, last2]区间中的任何元素匹配的元素。第一个版本使用值类型的= =运算符对元素进行比较；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(it1, it2)为true，则it1和it2指向的元素匹配。如果没有找到这样的元素，则它们都将返回last1。

10．adjacent_find()

template<class ForwardIterator>
ForwardIterator adjacent_find(ForwardIterator first,
         ForwardIterator last);
template<class ForwardIterator, class BinaryPredicate>
ForwardIterator adjacent_find(ForwardIterator first,
         ForwardIterator last, BinaryPredicate pred);

adjacent_find()函数返回一个迭代器，该迭代器指向[first1, last1] 区间中第一个与其后面的元素匹配的元素。如果没有找到这样的元素，则返回last。第一个版本使用值类型的= =运算符来对元素进行比较；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(it1, it2)为true，则it1和it2指向的元素匹配。

11．count()

template<class InputIterator, class T>
 typename iterator_traits<InputIterator>::difference_type
  count(InputIterator first, InputIterator last, const T& value);

count()函数返回[first, last)区间中与值value匹配的元素数目。对值进行比较时，将使用值类型的= =运算符。返回值类型为整型，它足以存储容器所能存储的最大元素数。

12．count_if()

template<class InputIterator, class Predicate>
 typename iterator_traits<InputIterator>::difference_type
  count_if(InputIterator first, InputIterator last, Predicate pred);

count if()函数返回[first, last]区间中这样的元素数目，即将其作为参数传递给函数对象pred时，后者的返回值为true。

13．mismatch()

template<class InputIterator1, class InputIterator2>
  pair<InputIterator1, InputIterator2>
   mismatch(InputIterator1 first1,
            InputIterator1 last1, InputIterator2 first2);
template<class InputIterator1, class InputIterator2,
                               class BinaryPredicate>
  pair<InputIterator1, InputIterator2>
    mismatch(InputIterator1 first1,
             InputIterator1 last1, InputIterator2 first2,
             BinaryPredicate pred);

每个mismatch()函数都在[first1, last1)区间中查找第一个与从first2开始的区间中相应元素不匹配的元素，并返回两个迭代器，它们指向不匹配的两个元素。如果没有发现不匹配的情况，则返回值为pair<last1, first2 + (last1 - first1)>。第一个版本使用= =运算符来测试匹配情况；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(it1, it2)为false，则it1和it2指向的元素不匹配。

14．equal()

template<class InputIterator1, class InputIterator2>
bool equal(InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2);
template<class InputIterator1, class InputIterator2,
         class BinaryPredicate>
bool equal(InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, BinaryPredicate pred);

如果[first1, last1)区间中每个元素都与以first2开始的序列中相应元素匹配，则equal()函数返回true，否则返回false。第一个版本使用值类型的= =运算符来比较元素；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(it1, it2)为true，则it1和it2指向的元素匹配。

15．is_permutation()（C++11）

template<class InputIterator1, class InputIterator2>
bool equal(InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2);
template<class InputIterator1, class InputIterator2,
         class BinaryPredicate>
bool equal(InputIterator1 first1, InputIterator1 last1,
           InputIterator2 first2, BinaryPredicate pred);

如果通过对从first2开始的序列进行排列，可使其与区间[first1, last1]相应的元素匹配，则函数is_permutation()返回true，否则返回false。第一个版本使用值类型的==运算符来比较元素；第二个版本使用二元谓词函数对象pred来比较元素，也就是说，如果pred(it1, it2)为true，则it1和it2指向的元素匹配。

16．search()

template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1 search(
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2,
         class BinaryPredicate>
ForwardIterator1 search(
         ForwardIterator1 first1, ForwardIterator1 last1,
         ForwardIterator2 first2, ForwardIterator2 last2,
         BinaryPredicate pred);

search()函数在[first1, last1]区间中搜索第一个与[first2, last2] 区间中相应的序列匹配的序列；如果没有找到这样的序列，则返回last1。第一个版本使用值类型的= =运算符来对元素进行比较；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(it1, it2)为true，则it1和it2指向的元素是匹配的。

17．search_n()

template<class ForwardIterator, class Size, class T>
ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                         Size count, const T& value);
template<class ForwardIterator, class Size, class T, class BinaryPredicate>
ForwardIterator search_n(ForwardIterator first, ForwardIterator last,
                          Size count, const T& value, BinaryPredicate pred);

search_n()函数在[first1, last1)区间中查找第一个与count个value组成的序列匹配的序列；如果没有找到这样的序列，则返回last1。第一个版本使用值类型的= =运算符来对元素进行比较；第二个版本使用二元谓词函数对象pred来比较元素。也就是说，如果pred(it1, it2)为true，则it1和it2指向的元素是匹配的。