libstdc++: algorithmfwd.h Source File

libstdc++

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