From Jason Turner

[alg.equal]

C++14 → C++17 3.5 KB 41 lines
Current Draft | LaTeX Source
Archived: C++14 | C++17
Markdown: C++14 | C++17
Explore in Adventure Game

Diff to HTML by rtfpessoa

Files changed (1) hide show
  1. tmp/tmp57ippuc5/{from.md → to.md} +33 -4
tmp/tmp57ippuc5/{from.md → to.md} RENAMED
@@ -2,25 +2,44 @@
2
 
3
  ``` cpp
4
  template<class InputIterator1, class InputIterator2>
5
  bool equal(InputIterator1 first1, InputIterator1 last1,
6
  InputIterator2 first2);
 
 
 
 
7
 
8
  template<class InputIterator1, class InputIterator2,
9
  class BinaryPredicate>
10
  bool equal(InputIterator1 first1, InputIterator1 last1,
11
  InputIterator2 first2, BinaryPredicate pred);
 
 
 
 
 
12
 
13
  template<class InputIterator1, class InputIterator2>
14
  bool equal(InputIterator1 first1, InputIterator1 last1,
15
  InputIterator2 first2, InputIterator2 last2);
 
 
 
 
16
 
17
  template<class InputIterator1, class InputIterator2,
18
  class BinaryPredicate>
19
  bool equal(InputIterator1 first1, InputIterator1 last1,
20
  InputIterator2 first2, InputIterator2 last2,
21
  BinaryPredicate pred);
 
 
 
 
 
 
22
  ```
23
 
24
  *Remarks:* If `last2` was not given in the argument list, it denotes
25
  `first2 + (last1 - first1)` below.
26
 
@@ -28,11 +47,21 @@ template<class InputIterator1, class InputIterator2,
28
  Otherwise return `true` if for every iterator `i` in the range
29
  \[`first1`, `last1`) the following corresponding conditions hold:
30
  `*i == *(first2 + (i - first1)), pred(*i, *(first2 + (i - first1))) != false`.
31
  Otherwise, returns `false`.
32
 
33
- *Complexity:* No applications of the corresponding predicate if
34
- `InputIterator1` and `InputIterator2` meet the requirements of random
35
- access iterators and `last1 - first1 != last2 - first2`. Otherwise, at
36
- most `min(last1 - first1, last2 - first2)` applications of the
 
 
 
 
 
 
 
 
 
 
37
  corresponding predicate.
38
 
 
2
 
3
  ``` cpp
4
  template<class InputIterator1, class InputIterator2>
5
  bool equal(InputIterator1 first1, InputIterator1 last1,
6
  InputIterator2 first2);
7
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
8
+ bool equal(ExecutionPolicy&& exec,
9
+ ForwardIterator1 first1, ForwardIterator1 last1,
10
+ ForwardIterator2 first2);
11
 
12
  template<class InputIterator1, class InputIterator2,
13
  class BinaryPredicate>
14
  bool equal(InputIterator1 first1, InputIterator1 last1,
15
  InputIterator2 first2, BinaryPredicate pred);
16
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
17
+ class BinaryPredicate>
18
+ bool equal(ExecutionPolicy&& exec,
19
+ ForwardIterator1 first1, ForwardIterator1 last1,
20
+ ForwardIterator2 first2, BinaryPredicate pred);
21
 
22
  template<class InputIterator1, class InputIterator2>
23
  bool equal(InputIterator1 first1, InputIterator1 last1,
24
  InputIterator2 first2, InputIterator2 last2);
25
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2>
26
+ bool equal(ExecutionPolicy&& exec,
27
+ ForwardIterator1 first1, ForwardIterator1 last1,
28
+ ForwardIterator2 first2, ForwardIterator2 last2);
29
 
30
  template<class InputIterator1, class InputIterator2,
31
  class BinaryPredicate>
32
  bool equal(InputIterator1 first1, InputIterator1 last1,
33
  InputIterator2 first2, InputIterator2 last2,
34
  BinaryPredicate pred);
35
+ template<class ExecutionPolicy, class ForwardIterator1, class ForwardIterator2,
36
+ class BinaryPredicate>
37
+ bool equal(ExecutionPolicy&& exec,
38
+ ForwardIterator1 first1, ForwardIterator1 last1,
39
+ ForwardIterator2 first2, ForwardIterator2 last2,
40
+ BinaryPredicate pred);
41
  ```
42
 
43
  *Remarks:* If `last2` was not given in the argument list, it denotes
44
  `first2 + (last1 - first1)` below.
45
 
 
47
  Otherwise return `true` if for every iterator `i` in the range
48
  \[`first1`, `last1`) the following corresponding conditions hold:
49
  `*i == *(first2 + (i - first1)), pred(*i, *(first2 + (i - first1))) != false`.
50
  Otherwise, returns `false`.
51
 
52
+ *Complexity:*
53
+
54
+ - For the overloads with no `ExecutionPolicy`,
55
+ - if `InputIterator1` and `InputIterator2` meet the requirements of
56
+ random access iterators ([[random.access.iterators]]) and
57
+ `last1 - first1 != last2 - first2`, then no applications of the
58
+ corresponding predicate; otherwise,
59
+ - at most min(`last1 - first1`, `last2 - first2`) applications of the
60
+ corresponding predicate.
61
+ - For the overloads with no `ExecutionPolicy`,
62
+ - if `ForwardIterator1` and `ForwardIterator2` meet the requirements
63
+ of random access iterators and `last1 - first1 != last2 - first2`,
64
+ then no applications of the corresponding predicate; otherwise,
65
+ - 𝑂(min(`last1 - first1`, `last2 - first2`)) applications of the
66
  corresponding predicate.
67