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