algorithmfwd.h source code [include/c++/7/bits/algorithmfwd.h]

1	// <algorithm> Forward declarations -- C++ --
2
3	// Copyright (C) 2007-2017 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 Operation
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 >= 201103L
195	template<typename _IIter, typename _Predicate>
196	bool
197	all_of(_IIter, _IIter, _Predicate);
198
199	template<typename _IIter, typename _Predicate>
200	bool
201	any_of(_IIter, _IIter, _Predicate);
202	#endif
203
204	template<typename _FIter, typename _Tp>
205	bool
206	binary_search(_FIter, _FIter, const _Tp&);
207
208	template<typename _FIter, typename _Tp, typename _Compare>
209	bool
210	binary_search(_FIter, _FIter, const _Tp&, _Compare);
211
212	#if __cplusplus > 201402L
213	template<typename _Tp>
214	_GLIBCXX14_CONSTEXPR
215	const _Tp&
216	clamp(const _Tp&, const _Tp&, const _Tp&);
217
218	template<typename _Tp, typename _Compare>
219	_GLIBCXX14_CONSTEXPR
220	const _Tp&
221	clamp(const _Tp&, const _Tp&, const _Tp&, _Compare);
222	#endif
223
224	template<typename _IIter, typename _OIter>
225	_OIter
226	copy(_IIter, _IIter, _OIter);
227
228	template<typename _BIter1, typename _BIter2>
229	_BIter2
230	copy_backward(_BIter1, _BIter1, _BIter2);
231
232	#if __cplusplus >= 201103L
233	template<typename _IIter, typename _OIter, typename _Predicate>
234	_OIter
235	copy_if(_IIter, _IIter, _OIter, _Predicate);
236
237	template<typename _IIter, typename _Size, typename _OIter>
238	_OIter
239	copy_n(_IIter, _Size, _OIter);
240	#endif
241
242	// count
243	// count_if
244
245	template<typename _FIter, typename _Tp>
246	pair<_FIter, _FIter>
247	equal_range(_FIter, _FIter, const _Tp&);
248
249	template<typename _FIter, typename _Tp, typename _Compare>
250	pair<_FIter, _FIter>
251	equal_range(_FIter, _FIter, const _Tp&, _Compare);
252
253	template<typename _FIter, typename _Tp>
254	void
255	fill(_FIter, _FIter, const _Tp&);
256
257	template<typename _OIter, typename _Size, typename _Tp>
258	_OIter
259	fill_n(_OIter, _Size, const _Tp&);
260
261	// find
262
263	template<typename _FIter1, typename _FIter2>
264	_FIter1
265	find_end(_FIter1, _FIter1, _FIter2, _FIter2);
266
267	template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
268	_FIter1
269	find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
270
271	// find_first_of
272	// find_if
273
274	#if __cplusplus >= 201103L
275	template<typename _IIter, typename _Predicate>
276	_IIter
277	find_if_not(_IIter, _IIter, _Predicate);
278	#endif
279
280	// for_each
281	// generate
282	// generate_n
283
284	template<typename _IIter1, typename _IIter2>
285	bool
286	includes(_IIter1, _IIter1, _IIter2, _IIter2);
287
288	template<typename _IIter1, typename _IIter2, typename _Compare>
289	bool
290	includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
291
292	template<typename _BIter>
293	void
294	inplace_merge(_BIter, _BIter, _BIter);
295
296	template<typename _BIter, typename _Compare>
297	void
298	inplace_merge(_BIter, _BIter, _BIter, _Compare);
299
300	#if __cplusplus >= 201103L
301	template<typename _RAIter>
302	bool
303	is_heap(_RAIter, _RAIter);
304
305	template<typename _RAIter, typename _Compare>
306	bool
307	is_heap(_RAIter, _RAIter, _Compare);
308
309	template<typename _RAIter>
310	_RAIter
311	is_heap_until(_RAIter, _RAIter);
312
313	template<typename _RAIter, typename _Compare>
314	_RAIter
315	is_heap_until(_RAIter, _RAIter, _Compare);
316
317	template<typename _IIter, typename _Predicate>
318	bool
319	is_partitioned(_IIter, _IIter, _Predicate);
320
321	template<typename _FIter1, typename _FIter2>
322	bool
323	is_permutation(_FIter1, _FIter1, _FIter2);
324
325	template<typename _FIter1, typename _FIter2,
326	typename _BinaryPredicate>
327	bool
328	is_permutation(_FIter1, _FIter1, _FIter2, _BinaryPredicate);
329
330	template<typename _FIter>
331	bool
332	is_sorted(_FIter, _FIter);
333
334	template<typename _FIter, typename _Compare>
335	bool
336	is_sorted(_FIter, _FIter, _Compare);
337
338	template<typename _FIter>
339	_FIter
340	is_sorted_until(_FIter, _FIter);
341
342	template<typename _FIter, typename _Compare>
343	_FIter
344	is_sorted_until(_FIter, _FIter, _Compare);
345	#endif
346
347	template<typename _FIter1, typename _FIter2>
348	void
349	iter_swap(_FIter1, _FIter2);
350
351	template<typename _FIter, typename _Tp>
352	_FIter
353	lower_bound(_FIter, _FIter, const _Tp&);
354
355	template<typename _FIter, typename _Tp, typename _Compare>
356	_FIter
357	lower_bound(_FIter, _FIter, const _Tp&, _Compare);
358
359	template<typename _RAIter>
360	void
361	make_heap(_RAIter, _RAIter);
362
363	template<typename _RAIter, typename _Compare>
364	void
365	make_heap(_RAIter, _RAIter, _Compare);
366
367	template<typename _Tp>
368	_GLIBCXX14_CONSTEXPR
369	const _Tp&
370	max(const _Tp&, const _Tp&);
371
372	template<typename _Tp, typename _Compare>
373	_GLIBCXX14_CONSTEXPR
374	const _Tp&
375	max(const _Tp&, const _Tp&, _Compare);
376
377	// max_element
378	// merge
379
380	template<typename _Tp>
381	_GLIBCXX14_CONSTEXPR
382	const _Tp&
383	min(const _Tp&, const _Tp&);
384
385	template<typename _Tp, typename _Compare>
386	_GLIBCXX14_CONSTEXPR
387	const _Tp&
388	min(const _Tp&, const _Tp&, _Compare);
389
390	// min_element
391
392	#if __cplusplus >= 201103L
393	template<typename _Tp>
394	_GLIBCXX14_CONSTEXPR
395	pair<const _Tp&, const _Tp&>
396	minmax(const _Tp&, const _Tp&);
397
398	template<typename _Tp, typename _Compare>
399	_GLIBCXX14_CONSTEXPR
400	pair<const _Tp&, const _Tp&>
401	minmax(const _Tp&, const _Tp&, _Compare);
402
403	template<typename _FIter>
404	_GLIBCXX14_CONSTEXPR
405	pair<_FIter, _FIter>
406	minmax_element(_FIter, _FIter);
407
408	template<typename _FIter, typename _Compare>
409	_GLIBCXX14_CONSTEXPR
410	pair<_FIter, _FIter>
411	minmax_element(_FIter, _FIter, _Compare);
412
413	template<typename _Tp>
414	_GLIBCXX14_CONSTEXPR
415	_Tp
416	min(initializer_list<_Tp>);
417
418	template<typename _Tp, typename _Compare>
419	_GLIBCXX14_CONSTEXPR
420	_Tp
421	min(initializer_list<_Tp>, _Compare);
422
423	template<typename _Tp>
424	_GLIBCXX14_CONSTEXPR
425	_Tp
426	max(initializer_list<_Tp>);
427
428	template<typename _Tp, typename _Compare>
429	_GLIBCXX14_CONSTEXPR
430	_Tp
431	max(initializer_list<_Tp>, _Compare);
432
433	template<typename _Tp>
434	_GLIBCXX14_CONSTEXPR
435	pair<_Tp, _Tp>
436	minmax(initializer_list<_Tp>);
437
438	template<typename _Tp, typename _Compare>
439	_GLIBCXX14_CONSTEXPR
440	pair<_Tp, _Tp>
441	minmax(initializer_list<_Tp>, _Compare);
442	#endif
443
444	// mismatch
445
446	template<typename _BIter>
447	bool
448	next_permutation(_BIter, _BIter);
449
450	template<typename _BIter, typename _Compare>
451	bool
452	next_permutation(_BIter, _BIter, _Compare);
453
454	#if __cplusplus >= 201103L
455	template<typename _IIter, typename _Predicate>
456	bool
457	none_of(_IIter, _IIter, _Predicate);
458	#endif
459
460	// nth_element
461	// partial_sort
462
463	template<typename _IIter, typename _RAIter>
464	_RAIter
465	partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
466
467	template<typename _IIter, typename _RAIter, typename _Compare>
468	_RAIter
469	partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
470
471	// partition
472
473	#if __cplusplus >= 201103L
474	template<typename _IIter, typename _OIter1,
475	typename _OIter2, typename _Predicate>
476	pair<_OIter1, _OIter2>
477	partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate);
478
479	template<typename _FIter, typename _Predicate>
480	_FIter
481	partition_point(_FIter, _FIter, _Predicate);
482	#endif
483
484	template<typename _RAIter>
485	void
486	pop_heap(_RAIter, _RAIter);
487
488	template<typename _RAIter, typename _Compare>
489	void
490	pop_heap(_RAIter, _RAIter, _Compare);
491
492	template<typename _BIter>
493	bool
494	prev_permutation(_BIter, _BIter);
495
496	template<typename _BIter, typename _Compare>
497	bool
498	prev_permutation(_BIter, _BIter, _Compare);
499
500	template<typename _RAIter>
501	void
502	push_heap(_RAIter, _RAIter);
503
504	template<typename _RAIter, typename _Compare>
505	void
506	push_heap(_RAIter, _RAIter, _Compare);
507
508	// random_shuffle
509
510	template<typename _FIter, typename _Tp>
511	_FIter
512	remove(_FIter, _FIter, const _Tp&);
513
514	template<typename _FIter, typename _Predicate>
515	_FIter
516	remove_if(_FIter, _FIter, _Predicate);
517
518	template<typename _IIter, typename _OIter, typename _Tp>
519	_OIter
520	remove_copy(_IIter, _IIter, _OIter, const _Tp&);
521
522	template<typename _IIter, typename _OIter, typename _Predicate>
523	_OIter
524	remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
525
526	// replace
527
528	template<typename _IIter, typename _OIter, typename _Tp>
529	_OIter
530	replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
531
532	template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
533	_OIter
534	replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
535
536	// replace_if
537
538	template<typename _BIter>
539	void
540	reverse(_BIter, _BIter);
541
542	template<typename _BIter, typename _OIter>
543	_OIter
544	reverse_copy(_BIter, _BIter, _OIter);
545
546	inline namespace _V2
547	{
548	template<typename _FIter>
549	_FIter
550	rotate(_FIter, _FIter, _FIter);
551	}
552
553	template<typename _FIter, typename _OIter>
554	_OIter
555	rotate_copy(_FIter, _FIter, _FIter, _OIter);
556
557	// search
558	// search_n
559	// set_difference
560	// set_intersection
561	// set_symmetric_difference
562	// set_union
563
564	#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1)
565	template<typename _RAIter, typename _UGenerator>
566	void
567	shuffle(_RAIter, _RAIter, _UGenerator&&);
568	#endif
569
570	template<typename _RAIter>
571	void
572	sort_heap(_RAIter, _RAIter);
573
574	template<typename _RAIter, typename _Compare>
575	void
576	sort_heap(_RAIter, _RAIter, _Compare);
577
578	template<typename _BIter, typename _Predicate>
579	_BIter
580	stable_partition(_BIter, _BIter, _Predicate);
581
582	#if __cplusplus < 201103L
583	// For C++11 swap() is declared in <type_traits>.
584
585	template<typename _Tp, size_t _Nm>
586	inline void
587	swap(_Tp& __a, _Tp& __b);
588
589	template<typename _Tp, size_t _Nm>
590	inline void
591	swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]);
592	#endif
593
594	template<typename _FIter1, typename _FIter2>
595	_FIter2
596	swap_ranges(_FIter1, _FIter1, _FIter2);
597
598	// transform
599
600	template<typename _FIter>
601	_FIter
602	unique(_FIter, _FIter);
603
604	template<typename _FIter, typename _BinaryPredicate>
605	_FIter
606	unique(_FIter, _FIter, _BinaryPredicate);
607
608	// unique_copy
609
610	template<typename _FIter, typename _Tp>
611	_FIter
612	upper_bound(_FIter, _FIter, const _Tp&);
613
614	template<typename _FIter, typename _Tp, typename _Compare>
615	_FIter
616	upper_bound(_FIter, _FIter, const _Tp&, _Compare);
617
618	_GLIBCXX_END_NAMESPACE_VERSION
619
620	_GLIBCXX_BEGIN_NAMESPACE_ALGO
621
622	template<typename _FIter>
623	_FIter
624	adjacent_find(_FIter, _FIter);
625
626	template<typename _FIter, typename _BinaryPredicate>
627	_FIter
628	adjacent_find(_FIter, _FIter, _BinaryPredicate);
629
630	template<typename _IIter, typename _Tp>
631	typename iterator_traits<_IIter>::difference_type
632	count(_IIter, _IIter, const _Tp&);
633
634	template<typename _IIter, typename _Predicate>
635	typename iterator_traits<_IIter>::difference_type
636	count_if(_IIter, _IIter, _Predicate);
637
638	template<typename _IIter1, typename _IIter2>
639	bool
640	equal(_IIter1, _IIter1, _IIter2);
641
642	template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
643	bool
644	equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
645
646	template<typename _IIter, typename _Tp>
647	_IIter
648	find(_IIter, _IIter, const _Tp&);
649
650	template<typename _FIter1, typename _FIter2>
651	_FIter1
652	find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
653
654	template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
655	_FIter1
656	find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
657
658	template<typename _IIter, typename _Predicate>
659	_IIter
660	find_if(_IIter, _IIter, _Predicate);
661
662	template<typename _IIter, typename _Funct>
663	_Funct
664	for_each(_IIter, _IIter, _Funct);
665
666	template<typename _FIter, typename _Generator>
667	void
668	generate(_FIter, _FIter, _Generator);
669
670	template<typename _OIter, typename _Size, typename _Generator>
671	_OIter
672	generate_n(_OIter, _Size, _Generator);
673
674	template<typename _IIter1, typename _IIter2>
675	bool
676	lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
677
678	template<typename _IIter1, typename _IIter2, typename _Compare>
679	bool
680	lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
681
682	template<typename _FIter>
683	_GLIBCXX14_CONSTEXPR
684	_FIter
685	max_element(_FIter, _FIter);
686
687	template<typename _FIter, typename _Compare>
688	_GLIBCXX14_CONSTEXPR
689	_FIter
690	max_element(_FIter, _FIter, _Compare);
691
692	template<typename _IIter1, typename _IIter2, typename _OIter>
693	_OIter
694	merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
695
696	template<typename _IIter1, typename _IIter2, typename _OIter,
697	typename _Compare>
698	_OIter
699	merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
700
701	template<typename _FIter>
702	_GLIBCXX14_CONSTEXPR
703	_FIter
704	min_element(_FIter, _FIter);
705
706	template<typename _FIter, typename _Compare>
707	_GLIBCXX14_CONSTEXPR
708	_FIter
709	min_element(_FIter, _FIter, _Compare);
710
711	template<typename _IIter1, typename _IIter2>
712	pair<_IIter1, _IIter2>
713	mismatch(_IIter1, _IIter1, _IIter2);
714
715	template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
716	pair<_IIter1, _IIter2>
717	mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
718
719	template<typename _RAIter>
720	void
721	nth_element(_RAIter, _RAIter, _RAIter);
722
723	template<typename _RAIter, typename _Compare>
724	void
725	nth_element(_RAIter, _RAIter, _RAIter, _Compare);
726
727	template<typename _RAIter>
728	void
729	partial_sort(_RAIter, _RAIter, _RAIter);
730
731	template<typename _RAIter, typename _Compare>
732	void
733	partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
734
735	template<typename _BIter, typename _Predicate>
736	_BIter
737	partition(_BIter, _BIter, _Predicate);
738
739	template<typename _RAIter>
740	void
741	random_shuffle(_RAIter, _RAIter);
742
743	template<typename _RAIter, typename _Generator>
744	void
745	random_shuffle(_RAIter, _RAIter,
746	#if __cplusplus >= 201103L
747	_Generator&&);
748	#else
749	_Generator&);
750	#endif
751
752	template<typename _FIter, typename _Tp>
753	void
754	replace(_FIter, _FIter, const _Tp&, const _Tp&);
755
756	template<typename _FIter, typename _Predicate, typename _Tp>
757	void
758	replace_if(_FIter, _FIter, _Predicate, const _Tp&);
759
760	template<typename _FIter1, typename _FIter2>
761	_FIter1
762	search(_FIter1, _FIter1, _FIter2, _FIter2);
763
764	template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
765	_FIter1
766	search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
767
768	template<typename _FIter, typename _Size, typename _Tp>
769	_FIter
770	search_n(_FIter, _FIter, _Size, const _Tp&);
771
772	template<typename _FIter, typename _Size, typename _Tp,
773	typename _BinaryPredicate>
774	_FIter
775	search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
776
777	template<typename _IIter1, typename _IIter2, typename _OIter>
778	_OIter
779	set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
780
781	template<typename _IIter1, typename _IIter2, typename _OIter,
782	typename _Compare>
783	_OIter
784	set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
785
786	template<typename _IIter1, typename _IIter2, typename _OIter>
787	_OIter
788	set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
789
790	template<typename _IIter1, typename _IIter2, typename _OIter,
791	typename _Compare>
792	_OIter
793	set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
794
795	template<typename _IIter1, typename _IIter2, typename _OIter>
796	_OIter
797	set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
798
799	template<typename _IIter1, typename _IIter2, typename _OIter,
800	typename _Compare>
801	_OIter
802	set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
803	_OIter, _Compare);
804
805	template<typename _IIter1, typename _IIter2, typename _OIter>
806	_OIter
807	set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
808
809	template<typename _IIter1, typename _IIter2, typename _OIter,
810	typename _Compare>
811	_OIter
812	set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
813
814	template<typename _RAIter>
815	void
816	sort(_RAIter, _RAIter);
817
818	template<typename _RAIter, typename _Compare>
819	void
820	sort(_RAIter, _RAIter, _Compare);
821
822	template<typename _RAIter>
823	void
824	stable_sort(_RAIter, _RAIter);
825
826	template<typename _RAIter, typename _Compare>
827	void
828	stable_sort(_RAIter, _RAIter, _Compare);
829
830	template<typename _IIter, typename _OIter, typename _UnaryOperation>
831	_OIter
832	transform(_IIter, _IIter, _OIter, _UnaryOperation);
833
834	template<typename _IIter1, typename _IIter2, typename _OIter,
835	typename _BinaryOperation>
836	_OIter
837	transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
838
839	template<typename _IIter, typename _OIter>
840	_OIter
841	unique_copy(_IIter, _IIter, _OIter);
842
843	template<typename _IIter, typename _OIter, typename _BinaryPredicate>
844	_OIter
845	unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
846
847	_GLIBCXX_END_NAMESPACE_ALGO
848	} // namespace std
849
850	#ifdef _GLIBCXX_PARALLEL
851	# include <parallel/algorithmfwd.h>
852	#endif
853
854	#endif
855
856

Clang Project