libstdc++
bits/algorithmfwd.h
Go to the documentation of this file.
1 // <algorithm> Forward declarations -*- C++ -*-
2 
3 // Copyright (C) 2007-2022 Free Software Foundation, Inc.
4 //
5 // This file is part of the GNU ISO C++ Library. This library is free
6 // software; you can redistribute it and/or modify it under the
7 // terms of the GNU General Public License as published by the
8 // Free Software Foundation; either version 3, or (at your option)
9 // any later version.
10 
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 // GNU General Public License for more details.
15 
16 // Under Section 7 of GPL version 3, you are granted additional
17 // permissions described in the GCC Runtime Library Exception, version
18 // 3.1, as published by the Free Software Foundation.
19 
20 // You should have received a copy of the GNU General Public License and
21 // a copy of the GCC Runtime Library Exception along with this program;
22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 // <http://www.gnu.org/licenses/>.
24 
25 /** @file bits/algorithmfwd.h
26  * This is an internal header file, included by other library headers.
27  * Do not attempt to use it directly. @headername{algorithm}
28  */
29 
30 #ifndef _GLIBCXX_ALGORITHMFWD_H
31 #define _GLIBCXX_ALGORITHMFWD_H 1
32 
33 #pragma GCC system_header
34 
35 #include <bits/c++config.h>
36 #include <bits/stl_pair.h>
37 #include <bits/stl_iterator_base_types.h>
38 #if __cplusplus >= 201103L
39 #include <initializer_list>
40 #endif
41 
42 namespace std _GLIBCXX_VISIBILITY(default)
43 {
44 _GLIBCXX_BEGIN_NAMESPACE_VERSION
45 
46  /*
47  adjacent_find
48  all_of (C++11)
49  any_of (C++11)
50  binary_search
51  clamp (C++17)
52  copy
53  copy_backward
54  copy_if (C++11)
55  copy_n (C++11)
56  count
57  count_if
58  equal
59  equal_range
60  fill
61  fill_n
62  find
63  find_end
64  find_first_of
65  find_if
66  find_if_not (C++11)
67  for_each
68  generate
69  generate_n
70  includes
71  inplace_merge
72  is_heap (C++11)
73  is_heap_until (C++11)
74  is_partitioned (C++11)
75  is_sorted (C++11)
76  is_sorted_until (C++11)
77  iter_swap
78  lexicographical_compare
79  lower_bound
80  make_heap
81  max
82  max_element
83  merge
84  min
85  min_element
86  minmax (C++11)
87  minmax_element (C++11)
88  mismatch
89  next_permutation
90  none_of (C++11)
91  nth_element
92  partial_sort
93  partial_sort_copy
94  partition
95  partition_copy (C++11)
96  partition_point (C++11)
97  pop_heap
98  prev_permutation
99  push_heap
100  random_shuffle
101  remove
102  remove_copy
103  remove_copy_if
104  remove_if
105  replace
106  replace_copy
107  replace_copy_if
108  replace_if
109  reverse
110  reverse_copy
111  rotate
112  rotate_copy
113  search
114  search_n
115  set_difference
116  set_intersection
117  set_symmetric_difference
118  set_union
119  shuffle (C++11)
120  sort
121  sort_heap
122  stable_partition
123  stable_sort
124  swap
125  swap_ranges
126  transform
127  unique
128  unique_copy
129  upper_bound
130  */
131 
132  /**
133  * @defgroup algorithms Algorithms
134  *
135  * Components for performing algorithmic operations. Includes
136  * non-modifying sequence, modifying (mutating) sequence, sorting,
137  * searching, merge, partition, heap, set, minima, maxima, and
138  * permutation operations.
139  */
140 
141  /**
142  * @defgroup mutating_algorithms Mutating
143  * @ingroup algorithms
144  */
145 
146  /**
147  * @defgroup non_mutating_algorithms Non-Mutating
148  * @ingroup algorithms
149  */
150 
151  /**
152  * @defgroup sorting_algorithms Sorting
153  * @ingroup algorithms
154  */
155 
156  /**
157  * @defgroup set_algorithms Set Operations
158  * @ingroup sorting_algorithms
159  *
160  * These algorithms are common set operations performed on sequences
161  * that are already sorted. The number of comparisons will be
162  * linear.
163  */
164 
165  /**
166  * @defgroup binary_search_algorithms Binary Search
167  * @ingroup sorting_algorithms
168  *
169  * These algorithms are variations of a classic binary search, and
170  * all assume that the sequence being searched is already sorted.
171  *
172  * The number of comparisons will be logarithmic (and as few as
173  * possible). The number of steps through the sequence will be
174  * logarithmic for random-access iterators (e.g., pointers), and
175  * linear otherwise.
176  *
177  * The LWG has passed Defect Report 270, which notes: <em>The
178  * proposed resolution reinterprets binary search. Instead of
179  * thinking about searching for a value in a sorted range, we view
180  * that as an important special case of a more general algorithm:
181  * searching for the partition point in a partitioned range. We
182  * also add a guarantee that the old wording did not: we ensure that
183  * the upper bound is no earlier than the lower bound, that the pair
184  * returned by equal_range is a valid range, and that the first part
185  * of that pair is the lower bound.</em>
186  *
187  * The actual effect of the first sentence is that a comparison
188  * functor passed by the user doesn't necessarily need to induce a
189  * strict weak ordering relation. Rather, it partitions the range.
190  */
191 
192  // adjacent_find
193 
194 #if __cplusplus > 201703L
195 # define __cpp_lib_constexpr_algorithms 201806L
196 #endif
197 
198 #if __cplusplus >= 201103L
199  template<typename _IIter, typename _Predicate>
200  _GLIBCXX20_CONSTEXPR
201  bool
202  all_of(_IIter, _IIter, _Predicate);
203 
204  template<typename _IIter, typename _Predicate>
205  _GLIBCXX20_CONSTEXPR
206  bool
207  any_of(_IIter, _IIter, _Predicate);
208 #endif
209 
210  template<typename _FIter, typename _Tp>
211  _GLIBCXX20_CONSTEXPR
212  bool
213  binary_search(_FIter, _FIter, const _Tp&);
214 
215  template<typename _FIter, typename _Tp, typename _Compare>
216  _GLIBCXX20_CONSTEXPR
217  bool
218  binary_search(_FIter, _FIter, const _Tp&, _Compare);
219 
220 #if __cplusplus > 201402L
221  template<typename _Tp>
222  _GLIBCXX14_CONSTEXPR
223  const _Tp&
224  clamp(const _Tp&, const _Tp&, const _Tp&);
225 
226  template<typename _Tp, typename _Compare>
227  _GLIBCXX14_CONSTEXPR
228  const _Tp&
229  clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);
230 #endif
231 
232  template<typename _IIter, typename _OIter>
233  _GLIBCXX20_CONSTEXPR
234  _OIter
235  copy(_IIter, _IIter, _OIter);
236 
237  template<typename _BIter1, typename _BIter2>
238  _GLIBCXX20_CONSTEXPR
239  _BIter2
240  copy_backward(_BIter1, _BIter1, _BIter2);
241 
242 #if __cplusplus >= 201103L
243  template<typename _IIter, typename _OIter, typename _Predicate>
244  _GLIBCXX20_CONSTEXPR
245  _OIter
246  copy_if(_IIter, _IIter, _OIter, _Predicate);
247 
248  template<typename _IIter, typename _Size, typename _OIter>
249  _GLIBCXX20_CONSTEXPR
250  _OIter
251  copy_n(_IIter, _Size, _OIter);
252 #endif
253 
254  // count
255  // count_if
256 
257  template<typename _FIter, typename _Tp>
258  _GLIBCXX20_CONSTEXPR
259  pair<_FIter, _FIter>
260  equal_range(_FIter, _FIter, const _Tp&);
261 
262  template<typename _FIter, typename _Tp, typename _Compare>
263  _GLIBCXX20_CONSTEXPR
264  pair<_FIter, _FIter>
265  equal_range(_FIter, _FIter, const _Tp&, _Compare);
266 
267  template<typename _FIter, typename _Tp>
268  _GLIBCXX20_CONSTEXPR
269  void
270  fill(_FIter, _FIter, const _Tp&);
271 
272  template<typename _OIter, typename _Size, typename _Tp>
273  _GLIBCXX20_CONSTEXPR
274  _OIter
275  fill_n(_OIter, _Size, const _Tp&);
276 
277  // find
278 
279  template<typename _FIter1, typename _FIter2>
280  _GLIBCXX20_CONSTEXPR
281  _FIter1
282  find_end(_FIter1, _FIter1, _FIter2, _FIter2);
283 
284  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
285  _GLIBCXX20_CONSTEXPR
286  _FIter1
287  find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
288 
289  // find_first_of
290  // find_if
291 
292 #if __cplusplus >= 201103L
293  template<typename _IIter, typename _Predicate>
294  _GLIBCXX20_CONSTEXPR
295  _IIter
296  find_if_not(_IIter, _IIter, _Predicate);
297 #endif
298 
299  // for_each
300  // generate
301  // generate_n
302 
303  template<typename _IIter1, typename _IIter2>
304  _GLIBCXX20_CONSTEXPR
305  bool
306  includes(_IIter1, _IIter1, _IIter2, _IIter2);
307 
308  template<typename _IIter1, typename _IIter2, typename _Compare>
309  _GLIBCXX20_CONSTEXPR
310  bool
311  includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
312 
313  template<typename _BIter>
314  void
315  inplace_merge(_BIter, _BIter, _BIter);
316 
317  template<typename _BIter, typename _Compare>
318  void
319  inplace_merge(_BIter, _BIter, _BIter, _Compare);
320 
321 #if __cplusplus >= 201103L
322  template<typename _RAIter>
323  _GLIBCXX20_CONSTEXPR
324  bool
325  is_heap(_RAIter, _RAIter);
326 
327  template<typename _RAIter, typename _Compare>
328  _GLIBCXX20_CONSTEXPR
329  bool
330  is_heap(_RAIter, _RAIter, _Compare);
331 
332  template<typename _RAIter>
333  _GLIBCXX20_CONSTEXPR
334  _RAIter
335  is_heap_until(_RAIter, _RAIter);
336 
337  template<typename _RAIter, typename _Compare>
338  _GLIBCXX20_CONSTEXPR
339  _RAIter
340  is_heap_until(_RAIter, _RAIter, _Compare);
341 
342  template<typename _IIter, typename _Predicate>
343  _GLIBCXX20_CONSTEXPR
344  bool
345  is_partitioned(_IIter, _IIter, _Predicate);
346 
347  template<typename _FIter1, typename _FIter2>
348  _GLIBCXX20_CONSTEXPR
349  bool
350  is_permutation(_FIter1, _FIter1, _FIter2);
351 
352  template<typename _FIter1, typename _FIter2,
353  typename _BinaryPredicate>
354  _GLIBCXX20_CONSTEXPR
355  bool
356  is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
357 
358  template<typename _FIter>
359  _GLIBCXX20_CONSTEXPR
360  bool
361  is_sorted(_FIter, _FIter);
362 
363  template<typename _FIter, typename _Compare>
364  _GLIBCXX20_CONSTEXPR
365  bool
366  is_sorted(_FIter, _FIter, _Compare);
367 
368  template<typename _FIter>
369  _GLIBCXX20_CONSTEXPR
370  _FIter
371  is_sorted_until(_FIter, _FIter);
372 
373  template<typename _FIter, typename _Compare>
374  _GLIBCXX20_CONSTEXPR
375  _FIter
376  is_sorted_until(_FIter, _FIter, _Compare);
377 #endif
378 
379  template<typename _FIter1, typename _FIter2>
380  _GLIBCXX20_CONSTEXPR
381  void
382  iter_swap(_FIter1, _FIter2);
383 
384  template<typename _FIter, typename _Tp>
385  _GLIBCXX20_CONSTEXPR
386  _FIter
387  lower_bound(_FIter, _FIter, const _Tp&);
388 
389  template<typename _FIter, typename _Tp, typename _Compare>
390  _GLIBCXX20_CONSTEXPR
391  _FIter
392  lower_bound(_FIter, _FIter, const _Tp&, _Compare);
393 
394  template<typename _RAIter>
395  _GLIBCXX20_CONSTEXPR
396  void
397  make_heap(_RAIter, _RAIter);
398 
399  template<typename _RAIter, typename _Compare>
400  _GLIBCXX20_CONSTEXPR
401  void
402  make_heap(_RAIter, _RAIter, _Compare);
403 
404  template<typename _Tp>
405  _GLIBCXX14_CONSTEXPR
406  const _Tp&
407  max(const _Tp&, const _Tp&);
408 
409  template<typename _Tp, typename _Compare>
410  _GLIBCXX14_CONSTEXPR
411  const _Tp&
412  max(const _Tp&, const _Tp&, _Compare);
413 
414  // max_element
415  // merge
416 
417  template<typename _Tp>
418  _GLIBCXX14_CONSTEXPR
419  const _Tp&
420  min(const _Tp&, const _Tp&);
421 
422  template<typename _Tp, typename _Compare>
423  _GLIBCXX14_CONSTEXPR
424  const _Tp&
425  min(const _Tp&, const _Tp&, _Compare);
426 
427  // min_element
428 
429 #if __cplusplus >= 201103L
430  template<typename _Tp>
431  _GLIBCXX14_CONSTEXPR
432  pair<const _Tp&, const _Tp&>
433  minmax(const _Tp&, const _Tp&);
434 
435  template<typename _Tp, typename _Compare>
436  _GLIBCXX14_CONSTEXPR
437  pair<const _Tp&, const _Tp&>
438  minmax(const _Tp&, const _Tp&, _Compare);
439 
440  template<typename _FIter>
441  _GLIBCXX14_CONSTEXPR
442  pair<_FIter, _FIter>
443  minmax_element(_FIter, _FIter);
444 
445  template<typename _FIter, typename _Compare>
446  _GLIBCXX14_CONSTEXPR
447  pair<_FIter, _FIter>
448  minmax_element(_FIter, _FIter, _Compare);
449 
450  template<typename _Tp>
451  _GLIBCXX14_CONSTEXPR
452  _Tp
453  min(initializer_list<_Tp>);
454 
455  template<typename _Tp, typename _Compare>
456  _GLIBCXX14_CONSTEXPR
457  _Tp
458  min(initializer_list<_Tp>, _Compare);
459 
460  template<typename _Tp>
461  _GLIBCXX14_CONSTEXPR
462  _Tp
463  max(initializer_list<_Tp>);
464 
465  template<typename _Tp, typename _Compare>
466  _GLIBCXX14_CONSTEXPR
467  _Tp
468  max(initializer_list<_Tp>, _Compare);
469 
470  template<typename _Tp>
471  _GLIBCXX14_CONSTEXPR
472  pair<_Tp, _Tp>
473  minmax(initializer_list<_Tp>);
474 
475  template<typename _Tp, typename _Compare>
476  _GLIBCXX14_CONSTEXPR
477  pair<_Tp, _Tp>
478  minmax(initializer_list<_Tp>, _Compare);
479 #endif
480 
481  // mismatch
482 
483  template<typename _BIter>
484  _GLIBCXX20_CONSTEXPR
485  bool
486  next_permutation(_BIter, _BIter);
487 
488  template<typename _BIter, typename _Compare>
489  _GLIBCXX20_CONSTEXPR
490  bool
491  next_permutation(_BIter, _BIter, _Compare);
492 
493 #if __cplusplus >= 201103L
494  template<typename _IIter, typename _Predicate>
495  _GLIBCXX20_CONSTEXPR
496  bool
497  none_of(_IIter, _IIter, _Predicate);
498 #endif
499 
500  // nth_element
501  // partial_sort
502 
503  template<typename _IIter, typename _RAIter>
504  _GLIBCXX20_CONSTEXPR
505  _RAIter
506  partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
507 
508  template<typename _IIter, typename _RAIter, typename _Compare>
509  _GLIBCXX20_CONSTEXPR
510  _RAIter
511  partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
512 
513  // partition
514 
515 #if __cplusplus >= 201103L
516  template<typename _IIter, typename _OIter1,
517  typename _OIter2, typename _Predicate>
518  _GLIBCXX20_CONSTEXPR
519  pair<_OIter1, _OIter2>
520  partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
521 
522  template<typename _FIter, typename _Predicate>
523  _GLIBCXX20_CONSTEXPR
524  _FIter
525  partition_point(_FIter, _FIter, _Predicate);
526 #endif
527 
528  template<typename _RAIter>
529  _GLIBCXX20_CONSTEXPR
530  void
531  pop_heap(_RAIter, _RAIter);
532 
533  template<typename _RAIter, typename _Compare>
534  _GLIBCXX20_CONSTEXPR
535  void
536  pop_heap(_RAIter, _RAIter, _Compare);
537 
538  template<typename _BIter>
539  _GLIBCXX20_CONSTEXPR
540  bool
541  prev_permutation(_BIter, _BIter);
542 
543  template<typename _BIter, typename _Compare>
544  _GLIBCXX20_CONSTEXPR
545  bool
546  prev_permutation(_BIter, _BIter, _Compare);
547 
548  template<typename _RAIter>
549  _GLIBCXX20_CONSTEXPR
550  void
551  push_heap(_RAIter, _RAIter);
552 
553  template<typename _RAIter, typename _Compare>
554  _GLIBCXX20_CONSTEXPR
555  void
556  push_heap(_RAIter, _RAIter, _Compare);
557 
558  // random_shuffle
559 
560  template<typename _FIter, typename _Tp>
561  _GLIBCXX20_CONSTEXPR
562  _FIter
563  remove(_FIter, _FIter, const _Tp&);
564 
565  template<typename _FIter, typename _Predicate>
566  _GLIBCXX20_CONSTEXPR
567  _FIter
568  remove_if(_FIter, _FIter, _Predicate);
569 
570  template<typename _IIter, typename _OIter, typename _Tp>
571  _GLIBCXX20_CONSTEXPR
572  _OIter
573  remove_copy(_IIter, _IIter, _OIter, const _Tp&);
574 
575  template<typename _IIter, typename _OIter, typename _Predicate>
576  _GLIBCXX20_CONSTEXPR
577  _OIter
578  remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
579 
580  // replace
581 
582  template<typename _IIter, typename _OIter, typename _Tp>
583  _GLIBCXX20_CONSTEXPR
584  _OIter
585  replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
586 
587  template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
588  _GLIBCXX20_CONSTEXPR
589  _OIter
590  replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
591 
592  // replace_if
593 
594  template<typename _BIter>
595  _GLIBCXX20_CONSTEXPR
596  void
597  reverse(_BIter, _BIter);
598 
599  template<typename _BIter, typename _OIter>
600  _GLIBCXX20_CONSTEXPR
601  _OIter
602  reverse_copy(_BIter, _BIter, _OIter);
603 
604 _GLIBCXX_BEGIN_INLINE_ABI_NAMESPACE(_V2)
605 
606  template<typename _FIter>
607  _GLIBCXX20_CONSTEXPR
608  _FIter
609  rotate(_FIter, _FIter, _FIter);
610 
611 _GLIBCXX_END_INLINE_ABI_NAMESPACE(_V2)
612 
613  template<typename _FIter, typename _OIter>
614  _GLIBCXX20_CONSTEXPR
615  _OIter
616  rotate_copy(_FIter, _FIter, _FIter, _OIter);
617 
618  // search
619  // search_n
620  // set_difference
621  // set_intersection
622  // set_symmetric_difference
623  // set_union
624 
625 #if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
626  template<typename _RAIter, typename _UGenerator>
627  void
628  shuffle(_RAIter, _RAIter, _UGenerator&&);
629 #endif
630 
631  template<typename _RAIter>
632  _GLIBCXX20_CONSTEXPR
633  void
634  sort_heap(_RAIter, _RAIter);
635 
636  template<typename _RAIter, typename _Compare>
637  _GLIBCXX20_CONSTEXPR
638  void
639  sort_heap(_RAIter, _RAIter, _Compare);
640 
641  template<typename _BIter, typename _Predicate>
642  _BIter
643  stable_partition(_BIter, _BIter, _Predicate);
644 
645 #if __cplusplus < 201103L
646  // For C++11 swap() is declared in <type_traits>.
647 
648  template<typename _Tp, size_t _Nm>
649  _GLIBCXX20_CONSTEXPR
650  inline void
651  swap(_Tp& __a, _Tp& __b);
652 
653  template<typename _Tp, size_t _Nm>
654  _GLIBCXX20_CONSTEXPR
655  inline void
656  swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]);
657 #endif
658 
659  template<typename _FIter1, typename _FIter2>
660  _GLIBCXX20_CONSTEXPR
661  _FIter2
662  swap_ranges(_FIter1, _FIter1, _FIter2);
663 
664  // transform
665 
666  template<typename _FIter>
667  _GLIBCXX20_CONSTEXPR
668  _FIter
669  unique(_FIter, _FIter);
670 
671  template<typename _FIter, typename _BinaryPredicate>
672  _GLIBCXX20_CONSTEXPR
673  _FIter
674  unique(_FIter, _FIter, _BinaryPredicate);
675 
676  // unique_copy
677 
678  template<typename _FIter, typename _Tp>
679  _GLIBCXX20_CONSTEXPR
680  _FIter
681  upper_bound(_FIter, _FIter, const _Tp&);
682 
683  template<typename _FIter, typename _Tp, typename _Compare>
684  _GLIBCXX20_CONSTEXPR
685  _FIter
686  upper_bound(_FIter, _FIter, const _Tp&, _Compare);
687 
688 _GLIBCXX_BEGIN_NAMESPACE_ALGO
689 
690  template<typename _FIter>
691  _GLIBCXX20_CONSTEXPR
692  _FIter
693  adjacent_find(_FIter, _FIter);
694 
695  template<typename _FIter, typename _BinaryPredicate>
696  _GLIBCXX20_CONSTEXPR
697  _FIter
698  adjacent_find(_FIter, _FIter, _BinaryPredicate);
699 
700  template<typename _IIter, typename _Tp>
701  _GLIBCXX20_CONSTEXPR
702  typename iterator_traits<_IIter>::difference_type
703  count(_IIter, _IIter, const _Tp&);
704 
705  template<typename _IIter, typename _Predicate>
706  _GLIBCXX20_CONSTEXPR
707  typename iterator_traits<_IIter>::difference_type
708  count_if(_IIter, _IIter, _Predicate);
709 
710  template<typename _IIter1, typename _IIter2>
711  _GLIBCXX20_CONSTEXPR
712  bool
713  equal(_IIter1, _IIter1, _IIter2);
714 
715  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
716  _GLIBCXX20_CONSTEXPR
717  bool
718  equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
719 
720  template<typename _IIter, typename _Tp>
721  _GLIBCXX20_CONSTEXPR
722  _IIter
723  find(_IIter, _IIter, const _Tp&);
724 
725  template<typename _FIter1, typename _FIter2>
726  _GLIBCXX20_CONSTEXPR
727  _FIter1
728  find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
729 
730  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
731  _GLIBCXX20_CONSTEXPR
732  _FIter1
733  find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
734 
735  template<typename _IIter, typename _Predicate>
736  _GLIBCXX20_CONSTEXPR
737  _IIter
738  find_if(_IIter, _IIter, _Predicate);
739 
740  template<typename _IIter, typename _Funct>
741  _GLIBCXX20_CONSTEXPR
742  _Funct
743  for_each(_IIter, _IIter, _Funct);
744 
745  template<typename _FIter, typename _Generator>
746  _GLIBCXX20_CONSTEXPR
747  void
748  generate(_FIter, _FIter, _Generator);
749 
750  template<typename _OIter, typename _Size, typename _Generator>
751  _GLIBCXX20_CONSTEXPR
752  _OIter
753  generate_n(_OIter, _Size, _Generator);
754 
755  template<typename _IIter1, typename _IIter2>
756  _GLIBCXX20_CONSTEXPR
757  bool
758  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
759 
760  template<typename _IIter1, typename _IIter2, typename _Compare>
761  _GLIBCXX20_CONSTEXPR
762  bool
763  lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
764 
765  template<typename _FIter>
766  _GLIBCXX14_CONSTEXPR
767  _FIter
768  max_element(_FIter, _FIter);
769 
770  template<typename _FIter, typename _Compare>
771  _GLIBCXX14_CONSTEXPR
772  _FIter
773  max_element(_FIter, _FIter, _Compare);
774 
775  template<typename _IIter1, typename _IIter2, typename _OIter>
776  _GLIBCXX20_CONSTEXPR
777  _OIter
778  merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
779 
780  template<typename _IIter1, typename _IIter2, typename _OIter,
781  typename _Compare>
782  _GLIBCXX20_CONSTEXPR
783  _OIter
784  merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
785 
786  template<typename _FIter>
787  _GLIBCXX14_CONSTEXPR
788  _FIter
789  min_element(_FIter, _FIter);
790 
791  template<typename _FIter, typename _Compare>
792  _GLIBCXX14_CONSTEXPR
793  _FIter
794  min_element(_FIter, _FIter, _Compare);
795 
796  template<typename _IIter1, typename _IIter2>
797  _GLIBCXX20_CONSTEXPR
798  pair<_IIter1, _IIter2>
799  mismatch(_IIter1, _IIter1, _IIter2);
800 
801  template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
802  _GLIBCXX20_CONSTEXPR
803  pair<_IIter1, _IIter2>
804  mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
805 
806  template<typename _RAIter>
807  _GLIBCXX20_CONSTEXPR
808  void
809  nth_element(_RAIter, _RAIter, _RAIter);
810 
811  template<typename _RAIter, typename _Compare>
812  _GLIBCXX20_CONSTEXPR
813  void
814  nth_element(_RAIter, _RAIter, _RAIter, _Compare);
815 
816  template<typename _RAIter>
817  _GLIBCXX20_CONSTEXPR
818  void
819  partial_sort(_RAIter, _RAIter, _RAIter);
820 
821  template<typename _RAIter, typename _Compare>
822  _GLIBCXX20_CONSTEXPR
823  void
824  partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
825 
826  template<typename _BIter, typename _Predicate>
827  _GLIBCXX20_CONSTEXPR
828  _BIter
829  partition(_BIter, _BIter, _Predicate);
830 
831  template<typename _RAIter>
832  _GLIBCXX14_DEPRECATED_SUGGEST("std::shuffle")
833  void
834  random_shuffle(_RAIter, _RAIter);
835 
836  template<typename _RAIter, typename _Generator>
837  _GLIBCXX14_DEPRECATED_SUGGEST("std::shuffle")
838  void
839  random_shuffle(_RAIter, _RAIter,
840 #if __cplusplus >= 201103L
841  _Generator&&);
842 #else
843  _Generator&);
844 #endif
845 
846  template<typename _FIter, typename _Tp>
847  _GLIBCXX20_CONSTEXPR
848  void
849  replace(_FIter, _FIter, const _Tp&, const _Tp&);
850 
851  template<typename _FIter, typename _Predicate, typename _Tp>
852  _GLIBCXX20_CONSTEXPR
853  void
854  replace_if(_FIter, _FIter, _Predicate, const _Tp&);
855 
856  template<typename _FIter1, typename _FIter2>
857  _GLIBCXX20_CONSTEXPR
858  _FIter1
859  search(_FIter1, _FIter1, _FIter2, _FIter2);
860 
861  template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
862  _GLIBCXX20_CONSTEXPR
863  _FIter1
864  search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
865 
866  template<typename _FIter, typename _Size, typename _Tp>
867  _GLIBCXX20_CONSTEXPR
868  _FIter
869  search_n(_FIter, _FIter, _Size, const _Tp&);
870 
871  template<typename _FIter, typename _Size, typename _Tp,
872  typename _BinaryPredicate>
873  _GLIBCXX20_CONSTEXPR
874  _FIter
875  search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
876 
877  template<typename _IIter1, typename _IIter2, typename _OIter>
878  _GLIBCXX20_CONSTEXPR
879  _OIter
880  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
881 
882  template<typename _IIter1, typename _IIter2, typename _OIter,
883  typename _Compare>
884  _GLIBCXX20_CONSTEXPR
885  _OIter
886  set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
887 
888  template<typename _IIter1, typename _IIter2, typename _OIter>
889  _GLIBCXX20_CONSTEXPR
890  _OIter
891  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
892 
893  template<typename _IIter1, typename _IIter2, typename _OIter,
894  typename _Compare>
895  _GLIBCXX20_CONSTEXPR
896  _OIter
897  set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
898 
899  template<typename _IIter1, typename _IIter2, typename _OIter>
900  _GLIBCXX20_CONSTEXPR
901  _OIter
902  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
903 
904  template<typename _IIter1, typename _IIter2, typename _OIter,
905  typename _Compare>
906  _GLIBCXX20_CONSTEXPR
907  _OIter
908  set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
909  _OIter, _Compare);
910 
911  template<typename _IIter1, typename _IIter2, typename _OIter>
912  _GLIBCXX20_CONSTEXPR
913  _OIter
914  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
915 
916  template<typename _IIter1, typename _IIter2, typename _OIter,
917  typename _Compare>
918  _GLIBCXX20_CONSTEXPR
919  _OIter
920  set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
921 
922  template<typename _RAIter>
923  _GLIBCXX20_CONSTEXPR
924  void
925  sort(_RAIter, _RAIter);
926 
927  template<typename _RAIter, typename _Compare>
928  _GLIBCXX20_CONSTEXPR
929  void
930  sort(_RAIter, _RAIter, _Compare);
931 
932  template<typename _RAIter>
933  void
934  stable_sort(_RAIter, _RAIter);
935 
936  template<typename _RAIter, typename _Compare>
937  void
938  stable_sort(_RAIter, _RAIter, _Compare);
939 
940  template<typename _IIter, typename _OIter, typename _UnaryOperation>
941  _GLIBCXX20_CONSTEXPR
942  _OIter
943  transform(_IIter, _IIter, _OIter, _UnaryOperation);
944 
945  template<typename _IIter1, typename _IIter2, typename _OIter,
946  typename _BinaryOperation>
947  _GLIBCXX20_CONSTEXPR
948  _OIter
949  transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
950 
951  template<typename _IIter, typename _OIter>
952  _GLIBCXX20_CONSTEXPR
953  _OIter
954  unique_copy(_IIter, _IIter, _OIter);
955 
956  template<typename _IIter, typename _OIter, typename _BinaryPredicate>
957  _GLIBCXX20_CONSTEXPR
958  _OIter
959  unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
960 
961 _GLIBCXX_END_NAMESPACE_ALGO
962 _GLIBCXX_END_NAMESPACE_VERSION
963 } // namespace std
964 
965 #ifdef _GLIBCXX_PARALLEL
966 # include <parallel/algorithmfwd.h>
967 #endif
968 
969 #endif
970 
std::minmax
constexpr pair< const _Tp &, const _Tp & > minmax(const _Tp &, const _Tp &)
Determines min and max at once as an ordered pair.
Definition: stl_algo.h:3290
stl_pair.h
std::max
constexpr const _Tp & max(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:254
std::min
constexpr const _Tp & min(const _Tp &, const _Tp &)
This does what you think it does.
Definition: stl_algobase.h:230
std::clamp
constexpr const _Tp & clamp(const _Tp &, const _Tp &, const _Tp &)
Returns the value clamped between lo and hi.
Definition: stl_algo.h:3627
std
ISO C++ entities toplevel namespace is std.
algorithmfwd.h
initializer_list
stl_iterator_base_types.h
c++config.h