1// <algorithm> Forward declarations -*- C++ -*- 2 3// Copyright (C) 2007-2013 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 42namespace 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 const _Tp& 356 max(const _Tp&, const _Tp&); 357 358 template<typename _Tp, typename _Compare> 359 const _Tp& 360 max(const _Tp&, const _Tp&, _Compare); 361 362 // max_element 363 // merge 364 365 template<typename _Tp> 366 const _Tp& 367 min(const _Tp&, const _Tp&); 368 369 template<typename _Tp, typename _Compare> 370 const _Tp& 371 min(const _Tp&, const _Tp&, _Compare); 372 373 // min_element 374 375#if __cplusplus >= 201103L 376 template<typename _Tp> 377 pair<const _Tp&, const _Tp&> 378 minmax(const _Tp&, const _Tp&); 379 380 template<typename _Tp, typename _Compare> 381 pair<const _Tp&, const _Tp&> 382 minmax(const _Tp&, const _Tp&, _Compare); 383 384 template<typename _FIter> 385 pair<_FIter, _FIter> 386 minmax_element(_FIter, _FIter); 387 388 template<typename _FIter, typename _Compare> 389 pair<_FIter, _FIter> 390 minmax_element(_FIter, _FIter, _Compare); 391 392 template<typename _Tp> 393 _Tp 394 min(initializer_list<_Tp>); 395 396 template<typename _Tp, typename _Compare> 397 _Tp 398 min(initializer_list<_Tp>, _Compare); 399 400 template<typename _Tp> 401 _Tp 402 max(initializer_list<_Tp>); 403 404 template<typename _Tp, typename _Compare> 405 _Tp 406 max(initializer_list<_Tp>, _Compare); 407 408 template<typename _Tp> 409 pair<_Tp, _Tp> 410 minmax(initializer_list<_Tp>); 411 412 template<typename _Tp, typename _Compare> 413 pair<_Tp, _Tp> 414 minmax(initializer_list<_Tp>, _Compare); 415#endif 416 417 // mismatch 418 419 template<typename _BIter> 420 bool 421 next_permutation(_BIter, _BIter); 422 423 template<typename _BIter, typename _Compare> 424 bool 425 next_permutation(_BIter, _BIter, _Compare); 426 427#if __cplusplus >= 201103L 428 template<typename _IIter, typename _Predicate> 429 bool 430 none_of(_IIter, _IIter, _Predicate); 431#endif 432 433 // nth_element 434 // partial_sort 435 436 template<typename _IIter, typename _RAIter> 437 _RAIter 438 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter); 439 440 template<typename _IIter, typename _RAIter, typename _Compare> 441 _RAIter 442 partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare); 443 444 // partition 445 446#if __cplusplus >= 201103L 447 template<typename _IIter, typename _OIter1, 448 typename _OIter2, typename _Predicate> 449 pair<_OIter1, _OIter2> 450 partition_copy(_IIter, _IIter, _OIter1, _OIter2, _Predicate); 451 452 template<typename _FIter, typename _Predicate> 453 _FIter 454 partition_point(_FIter, _FIter, _Predicate); 455#endif 456 457 template<typename _RAIter> 458 void 459 pop_heap(_RAIter, _RAIter); 460 461 template<typename _RAIter, typename _Compare> 462 void 463 pop_heap(_RAIter, _RAIter, _Compare); 464 465 template<typename _BIter> 466 bool 467 prev_permutation(_BIter, _BIter); 468 469 template<typename _BIter, typename _Compare> 470 bool 471 prev_permutation(_BIter, _BIter, _Compare); 472 473 template<typename _RAIter> 474 void 475 push_heap(_RAIter, _RAIter); 476 477 template<typename _RAIter, typename _Compare> 478 void 479 push_heap(_RAIter, _RAIter, _Compare); 480 481 // random_shuffle 482 483 template<typename _FIter, typename _Tp> 484 _FIter 485 remove(_FIter, _FIter, const _Tp&); 486 487 template<typename _FIter, typename _Predicate> 488 _FIter 489 remove_if(_FIter, _FIter, _Predicate); 490 491 template<typename _IIter, typename _OIter, typename _Tp> 492 _OIter 493 remove_copy(_IIter, _IIter, _OIter, const _Tp&); 494 495 template<typename _IIter, typename _OIter, typename _Predicate> 496 _OIter 497 remove_copy_if(_IIter, _IIter, _OIter, _Predicate); 498 499 // replace 500 501 template<typename _IIter, typename _OIter, typename _Tp> 502 _OIter 503 replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&); 504 505 template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp> 506 _OIter 507 replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&); 508 509 // replace_if 510 511 template<typename _BIter> 512 void 513 reverse(_BIter, _BIter); 514 515 template<typename _BIter, typename _OIter> 516 _OIter 517 reverse_copy(_BIter, _BIter, _OIter); 518 519 template<typename _FIter> 520 void 521 rotate(_FIter, _FIter, _FIter); 522 523 template<typename _FIter, typename _OIter> 524 _OIter 525 rotate_copy(_FIter, _FIter, _FIter, _OIter); 526 527 // search 528 // search_n 529 // set_difference 530 // set_intersection 531 // set_symmetric_difference 532 // set_union 533 534#if (__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99_STDINT_TR1) 535 template<typename _RAIter, typename _UGenerator> 536 void 537 shuffle(_RAIter, _RAIter, _UGenerator&&); 538#endif 539 540 template<typename _RAIter> 541 void 542 sort_heap(_RAIter, _RAIter); 543 544 template<typename _RAIter, typename _Compare> 545 void 546 sort_heap(_RAIter, _RAIter, _Compare); 547 548 template<typename _BIter, typename _Predicate> 549 _BIter 550 stable_partition(_BIter, _BIter, _Predicate); 551 552 template<typename _Tp> 553 void 554 swap(_Tp&, _Tp&) 555#if __cplusplus >= 201103L 556 noexcept(__and_<is_nothrow_move_constructible<_Tp>, 557 is_nothrow_move_assignable<_Tp>>::value) 558#endif 559 ; 560 561 template<typename _Tp, size_t _Nm> 562 void 563 swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm]) 564#if __cplusplus >= 201103L 565 noexcept(noexcept(swap(*__a, *__b))) 566#endif 567 ; 568 569 template<typename _FIter1, typename _FIter2> 570 _FIter2 571 swap_ranges(_FIter1, _FIter1, _FIter2); 572 573 // transform 574 575 template<typename _FIter> 576 _FIter 577 unique(_FIter, _FIter); 578 579 template<typename _FIter, typename _BinaryPredicate> 580 _FIter 581 unique(_FIter, _FIter, _BinaryPredicate); 582 583 // unique_copy 584 585 template<typename _FIter, typename _Tp> 586 _FIter 587 upper_bound(_FIter, _FIter, const _Tp&); 588 589 template<typename _FIter, typename _Tp, typename _Compare> 590 _FIter 591 upper_bound(_FIter, _FIter, const _Tp&, _Compare); 592 593_GLIBCXX_END_NAMESPACE_VERSION 594 595_GLIBCXX_BEGIN_NAMESPACE_ALGO 596 597 template<typename _FIter> 598 _FIter 599 adjacent_find(_FIter, _FIter); 600 601 template<typename _FIter, typename _BinaryPredicate> 602 _FIter 603 adjacent_find(_FIter, _FIter, _BinaryPredicate); 604 605 template<typename _IIter, typename _Tp> 606 typename iterator_traits<_IIter>::difference_type 607 count(_IIter, _IIter, const _Tp&); 608 609 template<typename _IIter, typename _Predicate> 610 typename iterator_traits<_IIter>::difference_type 611 count_if(_IIter, _IIter, _Predicate); 612 613 template<typename _IIter1, typename _IIter2> 614 bool 615 equal(_IIter1, _IIter1, _IIter2); 616 617 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 618 bool 619 equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 620 621 template<typename _IIter, typename _Tp> 622 _IIter 623 find(_IIter, _IIter, const _Tp&); 624 625 template<typename _FIter1, typename _FIter2> 626 _FIter1 627 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2); 628 629 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 630 _FIter1 631 find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 632 633 template<typename _IIter, typename _Predicate> 634 _IIter 635 find_if(_IIter, _IIter, _Predicate); 636 637 template<typename _IIter, typename _Funct> 638 _Funct 639 for_each(_IIter, _IIter, _Funct); 640 641 template<typename _FIter, typename _Generator> 642 void 643 generate(_FIter, _FIter, _Generator); 644 645 template<typename _OIter, typename _Size, typename _Generator> 646 _OIter 647 generate_n(_OIter, _Size, _Generator); 648 649 template<typename _IIter1, typename _IIter2> 650 bool 651 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2); 652 653 template<typename _IIter1, typename _IIter2, typename _Compare> 654 bool 655 lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare); 656 657 template<typename _FIter> 658 _FIter 659 max_element(_FIter, _FIter); 660 661 template<typename _FIter, typename _Compare> 662 _FIter 663 max_element(_FIter, _FIter, _Compare); 664 665 template<typename _IIter1, typename _IIter2, typename _OIter> 666 _OIter 667 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 668 669 template<typename _IIter1, typename _IIter2, typename _OIter, 670 typename _Compare> 671 _OIter 672 merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 673 674 template<typename _FIter> 675 _FIter 676 min_element(_FIter, _FIter); 677 678 template<typename _FIter, typename _Compare> 679 _FIter 680 min_element(_FIter, _FIter, _Compare); 681 682 template<typename _IIter1, typename _IIter2> 683 pair<_IIter1, _IIter2> 684 mismatch(_IIter1, _IIter1, _IIter2); 685 686 template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> 687 pair<_IIter1, _IIter2> 688 mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate); 689 690 template<typename _RAIter> 691 void 692 nth_element(_RAIter, _RAIter, _RAIter); 693 694 template<typename _RAIter, typename _Compare> 695 void 696 nth_element(_RAIter, _RAIter, _RAIter, _Compare); 697 698 template<typename _RAIter> 699 void 700 partial_sort(_RAIter, _RAIter, _RAIter); 701 702 template<typename _RAIter, typename _Compare> 703 void 704 partial_sort(_RAIter, _RAIter, _RAIter, _Compare); 705 706 template<typename _BIter, typename _Predicate> 707 _BIter 708 partition(_BIter, _BIter, _Predicate); 709 710 template<typename _RAIter> 711 void 712 random_shuffle(_RAIter, _RAIter); 713 714 template<typename _RAIter, typename _Generator> 715 void 716 random_shuffle(_RAIter, _RAIter, 717#if __cplusplus >= 201103L 718 _Generator&&); 719#else 720 _Generator&); 721#endif 722 723 template<typename _FIter, typename _Tp> 724 void 725 replace(_FIter, _FIter, const _Tp&, const _Tp&); 726 727 template<typename _FIter, typename _Predicate, typename _Tp> 728 void 729 replace_if(_FIter, _FIter, _Predicate, const _Tp&); 730 731 template<typename _FIter1, typename _FIter2> 732 _FIter1 733 search(_FIter1, _FIter1, _FIter2, _FIter2); 734 735 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate> 736 _FIter1 737 search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate); 738 739 template<typename _FIter, typename _Size, typename _Tp> 740 _FIter 741 search_n(_FIter, _FIter, _Size, const _Tp&); 742 743 template<typename _FIter, typename _Size, typename _Tp, 744 typename _BinaryPredicate> 745 _FIter 746 search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate); 747 748 template<typename _IIter1, typename _IIter2, typename _OIter> 749 _OIter 750 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 751 752 template<typename _IIter1, typename _IIter2, typename _OIter, 753 typename _Compare> 754 _OIter 755 set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 756 757 template<typename _IIter1, typename _IIter2, typename _OIter> 758 _OIter 759 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 760 761 template<typename _IIter1, typename _IIter2, typename _OIter, 762 typename _Compare> 763 _OIter 764 set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 765 766 template<typename _IIter1, typename _IIter2, typename _OIter> 767 _OIter 768 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 769 770 template<typename _IIter1, typename _IIter2, typename _OIter, 771 typename _Compare> 772 _OIter 773 set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, 774 _OIter, _Compare); 775 776 template<typename _IIter1, typename _IIter2, typename _OIter> 777 _OIter 778 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter); 779 780 template<typename _IIter1, typename _IIter2, typename _OIter, 781 typename _Compare> 782 _OIter 783 set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare); 784 785 template<typename _RAIter> 786 void 787 sort(_RAIter, _RAIter); 788 789 template<typename _RAIter, typename _Compare> 790 void 791 sort(_RAIter, _RAIter, _Compare); 792 793 template<typename _RAIter> 794 void 795 stable_sort(_RAIter, _RAIter); 796 797 template<typename _RAIter, typename _Compare> 798 void 799 stable_sort(_RAIter, _RAIter, _Compare); 800 801 template<typename _IIter, typename _OIter, typename _UnaryOperation> 802 _OIter 803 transform(_IIter, _IIter, _OIter, _UnaryOperation); 804 805 template<typename _IIter1, typename _IIter2, typename _OIter, 806 typename _BinaryOperation> 807 _OIter 808 transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation); 809 810 template<typename _IIter, typename _OIter> 811 _OIter 812 unique_copy(_IIter, _IIter, _OIter); 813 814 template<typename _IIter, typename _OIter, typename _BinaryPredicate> 815 _OIter 816 unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate); 817 818_GLIBCXX_END_NAMESPACE_ALGO 819} // namespace std 820 821#ifdef _GLIBCXX_PARALLEL 822# include <parallel/algorithmfwd.h> 823#endif 824 825#endif 826 827