包含

类别：算法	组件类型：函数

原型

template <class InputIterator1, class InputIterator2>
bool includes(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, InputIterator2 last2);

template <class InputIterator1, class InputIterator2, class StrictWeakOrdering>
bool includes(InputIterator1 first1, InputIterator1 last1,
              InputIterator2 first2, InputIterator2 last2, 
              StrictWeakOrdering comp);

描述

的两个版本包含在如何定义一个元素小于另一个元素方面有所不同。第一个版本使用operator<比较对象，第二个版本使用 函数对象comp.

定义

类型要求

• InputIterator1是 输入迭代器 的模型。
• InputIterator2是 输入迭代器 的模型。
• InputIterator1和InputIterator2具有相同的 value type。
• InputIterator的 value type 是 小于可比较 的模型。
• 对InputIterator1的 value type 的对象的排序是严格弱排序，如 小于可比较 要求中所定义。

• InputIterator1是 输入迭代器 的模型。
• InputIterator2是 输入迭代器 的模型。
• InputIterator1和InputIterator2具有相同的 value type。
• StrictWeakOrdering是 严格弱排序 的模型。
• InputIterator1的 value type 可转换为StrictWeakOrdering的参数类型。

先决条件

• [first1, last1)是一个有效的范围。
• [first2, last2)是一个有效的范围。
• [first1, last1)按照operator<升序排序。也就是说，对于每个迭代器对i和j在[first1, last1)中，使得i在j, *j < *i是false.
• [first2, last2)按照operator<升序排序。也就是说，对于每个迭代器对i和j在[first2, last2)中，使得i在j, *j < *i是false.

• [first1, last1)是一个有效的范围。
• [first2, last2)是一个有效的范围。
• [first1, last1)按照comp升序排序。也就是说，对于每个迭代器对i和j在[first1, last1)中，使得i在j, comp(*j, *i)是false.
• [first2, last2)按照comp升序排序。也就是说，对于每个迭代器对i和j在[first2, last2)中，使得i在j, comp(*j, *i)是false.

复杂度

示例

int A1[] = { 1, 2, 3, 4, 5, 6, 7 };
int A2[] = { 1, 4, 7 };
int A3[] = { 2, 7, 9 };
int A4[] = { 1, 1, 2, 3, 5, 8, 13, 21 };
int A5[] = { 1, 2, 13, 13 };
int A6[] = { 1, 1, 3, 21 };

const int N1 = sizeof(A1) / sizeof(int);
const int N2 = sizeof(A2) / sizeof(int);
const int N3 = sizeof(A3) / sizeof(int);
const int N4 = sizeof(A4) / sizeof(int);
const int N5 = sizeof(A5) / sizeof(int);
const int N6 = sizeof(A6) / sizeof(int);

cout << "A2 contained in A1: " 
     << (includes(A1, A1 + N1, A2, A2 + N2) ? "true" : "false") << endl;
cout << "A3 contained in A1: " 
     << (includes(A1, A1 + N2, A3, A3 + N3) ? "true" : "false") << endl;
cout << "A5 contained in A4: " 
     << (includes(A4, A4 + N4, A5, A5 + N5) ? "true" : "false") << endl;
cout << "A6 contained in A4: " 
     << (includes(A4, A4 + N4, A6, A6 + N6) ? "true" : "false") << endl;

A2 contained in A1: true
A3 contained in A1: false
A5 contained in A4: false
A6 contained in A4: true

注释

[1] 这写的是“等效元素”，而不是“相同元素”，因为输入范围排序所使用的排序被允许是严格弱排序，而不是全排序：可能存在值x和y它们是等效的（也就是说，既不是x < y也不是y < x为真），但并不相等。有关更详细的讨论，请参阅 小于可比较 要求。如果您使用的是全排序（例如，如果您使用的是strcmp，或者如果您在整数上使用普通的算术比较），那么您可以忽略此技术区别：对于全排序，相等和等效是相同的。

[2] 请注意，范围[first2, last2)可能包含一系列连续的等效元素：没有要求范围中的每个元素都是唯一的。在这种情况下，包含将返回false除非，对于[first2, last2)中的每个元素，一个不同的等效元素也存在于[first1, last1)中。也就是说，如果某个值在n次出现在[first2, last2)和m次出现在[first1, last1)中，那么包含将返回false如果m < n.

另请参阅