1 // Functor implementations -*- C++ -*- 2 3 // Copyright (C) 2001-2018 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 /* 26 * 27 * Copyright (c) 1994 28 * Hewlett-Packard Company 29 * 30 * Permission to use, copy, modify, distribute and sell this software 31 * and its documentation for any purpose is hereby granted without fee, 32 * provided that the above copyright notice appear in all copies and 33 * that both that copyright notice and this permission notice appear 34 * in supporting documentation. Hewlett-Packard Company makes no 35 * representations about the suitability of this software for any 36 * purpose. It is provided "as is" without express or implied warranty. 37 * 38 * 39 * Copyright (c) 1996-1998 40 * Silicon Graphics Computer Systems, Inc. 41 * 42 * Permission to use, copy, modify, distribute and sell this software 43 * and its documentation for any purpose is hereby granted without fee, 44 * provided that the above copyright notice appear in all copies and 45 * that both that copyright notice and this permission notice appear 46 * in supporting documentation. Silicon Graphics makes no 47 * representations about the suitability of this software for any 48 * purpose. It is provided "as is" without express or implied warranty. 49 */ 50 51 /** @file bits/stl_function.h 52 * This is an internal header file, included by other library headers. 53 * Do not attempt to use it directly. @headername{functional} 54 */ 55 56 #ifndef _STL_FUNCTION_H 57 #define _STL_FUNCTION_H 1 58 59 #if __cplusplus > 201103L 60 #include <bits/move.h> 61 #endif 62 63 namespace std _GLIBCXX_VISIBILITY(default) 64 { 65 _GLIBCXX_BEGIN_NAMESPACE_VERSION 66 67 // 20.3.1 base classes 68 /** @defgroup functors Function Objects 69 * @ingroup utilities 70 * 71 * Function objects, or @e functors, are objects with an @c operator() 72 * defined and accessible. They can be passed as arguments to algorithm 73 * templates and used in place of a function pointer. Not only is the 74 * resulting expressiveness of the library increased, but the generated 75 * code can be more efficient than what you might write by hand. When we 76 * refer to @a functors, then, generally we include function pointers in 77 * the description as well. 78 * 79 * Often, functors are only created as temporaries passed to algorithm 80 * calls, rather than being created as named variables. 81 * 82 * Two examples taken from the standard itself follow. To perform a 83 * by-element addition of two vectors @c a and @c b containing @c double, 84 * and put the result in @c a, use 85 * \code 86 * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>()); 87 * \endcode 88 * To negate every element in @c a, use 89 * \code 90 * transform(a.begin(), a.end(), a.begin(), negate<double>()); 91 * \endcode 92 * The addition and negation functions will be inlined directly. 93 * 94 * The standard functors are derived from structs named @c unary_function 95 * and @c binary_function. These two classes contain nothing but typedefs, 96 * to aid in generic (template) programming. If you write your own 97 * functors, you might consider doing the same. 98 * 99 * @{ 100 */ 101 /** 102 * This is one of the @link functors functor base classes@endlink. 103 */ 104 template<typename _Arg, typename _Result> 105 struct unary_function 106 { 107 /// @c argument_type is the type of the argument 108 typedef _Arg argument_type; 109 110 /// @c result_type is the return type 111 typedef _Result result_type; 112 }; 113 114 /** 115 * This is one of the @link functors functor base classes@endlink. 116 */ 117 template<typename _Arg1, typename _Arg2, typename _Result> 118 struct binary_function 119 { 120 /// @c first_argument_type is the type of the first argument 121 typedef _Arg1 first_argument_type; 122 123 /// @c second_argument_type is the type of the second argument 124 typedef _Arg2 second_argument_type; 125 126 /// @c result_type is the return type 127 typedef _Result result_type; 128 }; 129 /** @} */ 130 131 // 20.3.2 arithmetic 132 /** @defgroup arithmetic_functors Arithmetic Classes 133 * @ingroup functors 134 * 135 * Because basic math often needs to be done during an algorithm, 136 * the library provides functors for those operations. See the 137 * documentation for @link functors the base classes@endlink 138 * for examples of their use. 139 * 140 * @{ 141 */ 142 143 #if __cplusplus > 201103L 144 struct __is_transparent; // undefined 145 146 template<typename _Tp = void> 147 struct plus; 148 149 template<typename _Tp = void> 150 struct minus; 151 152 template<typename _Tp = void> 153 struct multiplies; 154 155 template<typename _Tp = void> 156 struct divides; 157 158 template<typename _Tp = void> 159 struct modulus; 160 161 template<typename _Tp = void> 162 struct negate; 163 #endif 164 165 /// One of the @link arithmetic_functors math functors@endlink. 166 template<typename _Tp> 167 struct plus : public binary_function<_Tp, _Tp, _Tp> 168 { 169 _GLIBCXX14_CONSTEXPR 170 _Tp 171 operator()(const _Tp& __x, const _Tp& __y) const 172 { return __x + __y; } 173 }; 174 175 /// One of the @link arithmetic_functors math functors@endlink. 176 template<typename _Tp> 177 struct minus : public binary_function<_Tp, _Tp, _Tp> 178 { 179 _GLIBCXX14_CONSTEXPR 180 _Tp 181 operator()(const _Tp& __x, const _Tp& __y) const 182 { return __x - __y; } 183 }; 184 185 /// One of the @link arithmetic_functors math functors@endlink. 186 template<typename _Tp> 187 struct multiplies : public binary_function<_Tp, _Tp, _Tp> 188 { 189 _GLIBCXX14_CONSTEXPR 190 _Tp 191 operator()(const _Tp& __x, const _Tp& __y) const 192 { return __x * __y; } 193 }; 194 195 /// One of the @link arithmetic_functors math functors@endlink. 196 template<typename _Tp> 197 struct divides : public binary_function<_Tp, _Tp, _Tp> 198 { 199 _GLIBCXX14_CONSTEXPR 200 _Tp 201 operator()(const _Tp& __x, const _Tp& __y) const 202 { return __x / __y; } 203 }; 204 205 /// One of the @link arithmetic_functors math functors@endlink. 206 template<typename _Tp> 207 struct modulus : public binary_function<_Tp, _Tp, _Tp> 208 { 209 _GLIBCXX14_CONSTEXPR 210 _Tp 211 operator()(const _Tp& __x, const _Tp& __y) const 212 { return __x % __y; } 213 }; 214 215 /// One of the @link arithmetic_functors math functors@endlink. 216 template<typename _Tp> 217 struct negate : public unary_function<_Tp, _Tp> 218 { 219 _GLIBCXX14_CONSTEXPR 220 _Tp 221 operator()(const _Tp& __x) const 222 { return -__x; } 223 }; 224 225 #if __cplusplus > 201103L 226 227 #define __cpp_lib_transparent_operators 201510 228 229 template<> 230 struct plus<void> 231 { 232 template <typename _Tp, typename _Up> 233 _GLIBCXX14_CONSTEXPR 234 auto 235 operator()(_Tp&& __t, _Up&& __u) const 236 noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u))) 237 -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u)) 238 { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); } 239 240 typedef __is_transparent is_transparent; 241 }; 242 243 /// One of the @link arithmetic_functors math functors@endlink. 244 template<> 245 struct minus<void> 246 { 247 template <typename _Tp, typename _Up> 248 _GLIBCXX14_CONSTEXPR 249 auto 250 operator()(_Tp&& __t, _Up&& __u) const 251 noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u))) 252 -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u)) 253 { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); } 254 255 typedef __is_transparent is_transparent; 256 }; 257 258 /// One of the @link arithmetic_functors math functors@endlink. 259 template<> 260 struct multiplies<void> 261 { 262 template <typename _Tp, typename _Up> 263 _GLIBCXX14_CONSTEXPR 264 auto 265 operator()(_Tp&& __t, _Up&& __u) const 266 noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u))) 267 -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u)) 268 { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); } 269 270 typedef __is_transparent is_transparent; 271 }; 272 273 /// One of the @link arithmetic_functors math functors@endlink. 274 template<> 275 struct divides<void> 276 { 277 template <typename _Tp, typename _Up> 278 _GLIBCXX14_CONSTEXPR 279 auto 280 operator()(_Tp&& __t, _Up&& __u) const 281 noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u))) 282 -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u)) 283 { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); } 284 285 typedef __is_transparent is_transparent; 286 }; 287 288 /// One of the @link arithmetic_functors math functors@endlink. 289 template<> 290 struct modulus<void> 291 { 292 template <typename _Tp, typename _Up> 293 _GLIBCXX14_CONSTEXPR 294 auto 295 operator()(_Tp&& __t, _Up&& __u) const 296 noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u))) 297 -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u)) 298 { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); } 299 300 typedef __is_transparent is_transparent; 301 }; 302 303 /// One of the @link arithmetic_functors math functors@endlink. 304 template<> 305 struct negate<void> 306 { 307 template <typename _Tp> 308 _GLIBCXX14_CONSTEXPR 309 auto 310 operator()(_Tp&& __t) const 311 noexcept(noexcept(-std::forward<_Tp>(__t))) 312 -> decltype(-std::forward<_Tp>(__t)) 313 { return -std::forward<_Tp>(__t); } 314 315 typedef __is_transparent is_transparent; 316 }; 317 #endif 318 /** @} */ 319 320 // 20.3.3 comparisons 321 /** @defgroup comparison_functors Comparison Classes 322 * @ingroup functors 323 * 324 * The library provides six wrapper functors for all the basic comparisons 325 * in C++, like @c <. 326 * 327 * @{ 328 */ 329 #if __cplusplus > 201103L 330 template<typename _Tp = void> 331 struct equal_to; 332 333 template<typename _Tp = void> 334 struct not_equal_to; 335 336 template<typename _Tp = void> 337 struct greater; 338 339 template<typename _Tp = void> 340 struct less; 341 342 template<typename _Tp = void> 343 struct greater_equal; 344 345 template<typename _Tp = void> 346 struct less_equal; 347 #endif 348 349 /// One of the @link comparison_functors comparison functors@endlink. 350 template<typename _Tp> 351 struct equal_to : public binary_function<_Tp, _Tp, bool> 352 { 353 _GLIBCXX14_CONSTEXPR 354 bool 355 operator()(const _Tp& __x, const _Tp& __y) const 356 { return __x == __y; } 357 }; 358 359 /// One of the @link comparison_functors comparison functors@endlink. 360 template<typename _Tp> 361 struct not_equal_to : public binary_function<_Tp, _Tp, bool> 362 { 363 _GLIBCXX14_CONSTEXPR 364 bool 365 operator()(const _Tp& __x, const _Tp& __y) const 366 { return __x != __y; } 367 }; 368 369 /// One of the @link comparison_functors comparison functors@endlink. 370 template<typename _Tp> 371 struct greater : public binary_function<_Tp, _Tp, bool> 372 { 373 _GLIBCXX14_CONSTEXPR 374 bool 375 operator()(const _Tp& __x, const _Tp& __y) const 376 { return __x > __y; } 377 }; 378 379 /// One of the @link comparison_functors comparison functors@endlink. 380 template<typename _Tp> 381 struct less : public binary_function<_Tp, _Tp, bool> 382 { 383 _GLIBCXX14_CONSTEXPR 384 bool 385 operator()(const _Tp& __x, const _Tp& __y) const 386 { return __x < __y; } 387 }; 388 389 /// One of the @link comparison_functors comparison functors@endlink. 390 template<typename _Tp> 391 struct greater_equal : public binary_function<_Tp, _Tp, bool> 392 { 393 _GLIBCXX14_CONSTEXPR 394 bool 395 operator()(const _Tp& __x, const _Tp& __y) const 396 { return __x >= __y; } 397 }; 398 399 /// One of the @link comparison_functors comparison functors@endlink. 400 template<typename _Tp> 401 struct less_equal : public binary_function<_Tp, _Tp, bool> 402 { 403 _GLIBCXX14_CONSTEXPR 404 bool 405 operator()(const _Tp& __x, const _Tp& __y) const 406 { return __x <= __y; } 407 }; 408 409 // Partial specialization of std::greater for pointers. 410 template<typename _Tp> 411 struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool> 412 { 413 _GLIBCXX14_CONSTEXPR bool 414 operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW 415 { 416 if (__builtin_constant_p (__x > __y)) 417 return __x > __y; 418 return (__UINTPTR_TYPE__)__x > (__UINTPTR_TYPE__)__y; 419 } 420 }; 421 422 // Partial specialization of std::less for pointers. 423 template<typename _Tp> 424 struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool> 425 { 426 _GLIBCXX14_CONSTEXPR bool 427 operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW 428 { 429 if (__builtin_constant_p (__x < __y)) 430 return __x < __y; 431 return (__UINTPTR_TYPE__)__x < (__UINTPTR_TYPE__)__y; 432 } 433 }; 434 435 // Partial specialization of std::greater_equal for pointers. 436 template<typename _Tp> 437 struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> 438 { 439 _GLIBCXX14_CONSTEXPR bool 440 operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW 441 { 442 if (__builtin_constant_p (__x >= __y)) 443 return __x >= __y; 444 return (__UINTPTR_TYPE__)__x >= (__UINTPTR_TYPE__)__y; 445 } 446 }; 447 448 // Partial specialization of std::less_equal for pointers. 449 template<typename _Tp> 450 struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool> 451 { 452 _GLIBCXX14_CONSTEXPR bool 453 operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW 454 { 455 if (__builtin_constant_p (__x <= __y)) 456 return __x <= __y; 457 return (__UINTPTR_TYPE__)__x <= (__UINTPTR_TYPE__)__y; 458 } 459 }; 460 461 #if __cplusplus >= 201402L 462 /// One of the @link comparison_functors comparison functors@endlink. 463 template<> 464 struct equal_to<void> 465 { 466 template <typename _Tp, typename _Up> 467 constexpr auto 468 operator()(_Tp&& __t, _Up&& __u) const 469 noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u))) 470 -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u)) 471 { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); } 472 473 typedef __is_transparent is_transparent; 474 }; 475 476 /// One of the @link comparison_functors comparison functors@endlink. 477 template<> 478 struct not_equal_to<void> 479 { 480 template <typename _Tp, typename _Up> 481 constexpr auto 482 operator()(_Tp&& __t, _Up&& __u) const 483 noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u))) 484 -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u)) 485 { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); } 486 487 typedef __is_transparent is_transparent; 488 }; 489 490 /// One of the @link comparison_functors comparison functors@endlink. 491 template<> 492 struct greater<void> 493 { 494 template <typename _Tp, typename _Up> 495 constexpr auto 496 operator()(_Tp&& __t, _Up&& __u) const 497 noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u))) 498 -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u)) 499 { 500 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), 501 __ptr_cmp<_Tp, _Up>{}); 502 } 503 504 template<typename _Tp, typename _Up> 505 constexpr bool 506 operator()(_Tp* __t, _Up* __u) const noexcept 507 { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); } 508 509 typedef __is_transparent is_transparent; 510 511 private: 512 template <typename _Tp, typename _Up> 513 static constexpr decltype(auto) 514 _S_cmp(_Tp&& __t, _Up&& __u, false_type) 515 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); } 516 517 template <typename _Tp, typename _Up> 518 static constexpr bool 519 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept 520 { 521 return greater<const volatile void*>{}( 522 static_cast<const volatile void*>(std::forward<_Tp>(__t)), 523 static_cast<const volatile void*>(std::forward<_Up>(__u))); 524 } 525 526 // True if there is no viable operator> member function. 527 template<typename _Tp, typename _Up, typename = void> 528 struct __not_overloaded2 : true_type { }; 529 530 // False if we can call T.operator>(U) 531 template<typename _Tp, typename _Up> 532 struct __not_overloaded2<_Tp, _Up, __void_t< 533 decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>> 534 : false_type { }; 535 536 // True if there is no overloaded operator> for these operands. 537 template<typename _Tp, typename _Up, typename = void> 538 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; 539 540 // False if we can call operator>(T,U) 541 template<typename _Tp, typename _Up> 542 struct __not_overloaded<_Tp, _Up, __void_t< 543 decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>> 544 : false_type { }; 545 546 template<typename _Tp, typename _Up> 547 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, 548 is_convertible<_Tp, const volatile void*>, 549 is_convertible<_Up, const volatile void*>>; 550 }; 551 552 /// One of the @link comparison_functors comparison functors@endlink. 553 template<> 554 struct less<void> 555 { 556 template <typename _Tp, typename _Up> 557 constexpr auto 558 operator()(_Tp&& __t, _Up&& __u) const 559 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u))) 560 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u)) 561 { 562 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), 563 __ptr_cmp<_Tp, _Up>{}); 564 } 565 566 template<typename _Tp, typename _Up> 567 constexpr bool 568 operator()(_Tp* __t, _Up* __u) const noexcept 569 { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); } 570 571 typedef __is_transparent is_transparent; 572 573 private: 574 template <typename _Tp, typename _Up> 575 static constexpr decltype(auto) 576 _S_cmp(_Tp&& __t, _Up&& __u, false_type) 577 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); } 578 579 template <typename _Tp, typename _Up> 580 static constexpr bool 581 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept 582 { 583 return less<const volatile void*>{}( 584 static_cast<const volatile void*>(std::forward<_Tp>(__t)), 585 static_cast<const volatile void*>(std::forward<_Up>(__u))); 586 } 587 588 // True if there is no viable operator< member function. 589 template<typename _Tp, typename _Up, typename = void> 590 struct __not_overloaded2 : true_type { }; 591 592 // False if we can call T.operator<(U) 593 template<typename _Tp, typename _Up> 594 struct __not_overloaded2<_Tp, _Up, __void_t< 595 decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>> 596 : false_type { }; 597 598 // True if there is no overloaded operator< for these operands. 599 template<typename _Tp, typename _Up, typename = void> 600 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; 601 602 // False if we can call operator<(T,U) 603 template<typename _Tp, typename _Up> 604 struct __not_overloaded<_Tp, _Up, __void_t< 605 decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>> 606 : false_type { }; 607 608 template<typename _Tp, typename _Up> 609 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, 610 is_convertible<_Tp, const volatile void*>, 611 is_convertible<_Up, const volatile void*>>; 612 }; 613 614 /// One of the @link comparison_functors comparison functors@endlink. 615 template<> 616 struct greater_equal<void> 617 { 618 template <typename _Tp, typename _Up> 619 constexpr auto 620 operator()(_Tp&& __t, _Up&& __u) const 621 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))) 622 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)) 623 { 624 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), 625 __ptr_cmp<_Tp, _Up>{}); 626 } 627 628 template<typename _Tp, typename _Up> 629 constexpr bool 630 operator()(_Tp* __t, _Up* __u) const noexcept 631 { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); } 632 633 typedef __is_transparent is_transparent; 634 635 private: 636 template <typename _Tp, typename _Up> 637 static constexpr decltype(auto) 638 _S_cmp(_Tp&& __t, _Up&& __u, false_type) 639 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); } 640 641 template <typename _Tp, typename _Up> 642 static constexpr bool 643 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept 644 { 645 return greater_equal<const volatile void*>{}( 646 static_cast<const volatile void*>(std::forward<_Tp>(__t)), 647 static_cast<const volatile void*>(std::forward<_Up>(__u))); 648 } 649 650 // True if there is no viable operator>= member function. 651 template<typename _Tp, typename _Up, typename = void> 652 struct __not_overloaded2 : true_type { }; 653 654 // False if we can call T.operator>=(U) 655 template<typename _Tp, typename _Up> 656 struct __not_overloaded2<_Tp, _Up, __void_t< 657 decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>> 658 : false_type { }; 659 660 // True if there is no overloaded operator>= for these operands. 661 template<typename _Tp, typename _Up, typename = void> 662 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; 663 664 // False if we can call operator>=(T,U) 665 template<typename _Tp, typename _Up> 666 struct __not_overloaded<_Tp, _Up, __void_t< 667 decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>> 668 : false_type { }; 669 670 template<typename _Tp, typename _Up> 671 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, 672 is_convertible<_Tp, const volatile void*>, 673 is_convertible<_Up, const volatile void*>>; 674 }; 675 676 /// One of the @link comparison_functors comparison functors@endlink. 677 template<> 678 struct less_equal<void> 679 { 680 template <typename _Tp, typename _Up> 681 constexpr auto 682 operator()(_Tp&& __t, _Up&& __u) const 683 noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))) 684 -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)) 685 { 686 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u), 687 __ptr_cmp<_Tp, _Up>{}); 688 } 689 690 template<typename _Tp, typename _Up> 691 constexpr bool 692 operator()(_Tp* __t, _Up* __u) const noexcept 693 { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); } 694 695 typedef __is_transparent is_transparent; 696 697 private: 698 template <typename _Tp, typename _Up> 699 static constexpr decltype(auto) 700 _S_cmp(_Tp&& __t, _Up&& __u, false_type) 701 { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); } 702 703 template <typename _Tp, typename _Up> 704 static constexpr bool 705 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept 706 { 707 return less_equal<const volatile void*>{}( 708 static_cast<const volatile void*>(std::forward<_Tp>(__t)), 709 static_cast<const volatile void*>(std::forward<_Up>(__u))); 710 } 711 712 // True if there is no viable operator<= member function. 713 template<typename _Tp, typename _Up, typename = void> 714 struct __not_overloaded2 : true_type { }; 715 716 // False if we can call T.operator<=(U) 717 template<typename _Tp, typename _Up> 718 struct __not_overloaded2<_Tp, _Up, __void_t< 719 decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>> 720 : false_type { }; 721 722 // True if there is no overloaded operator<= for these operands. 723 template<typename _Tp, typename _Up, typename = void> 724 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { }; 725 726 // False if we can call operator<=(T,U) 727 template<typename _Tp, typename _Up> 728 struct __not_overloaded<_Tp, _Up, __void_t< 729 decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>> 730 : false_type { }; 731 732 template<typename _Tp, typename _Up> 733 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>, 734 is_convertible<_Tp, const volatile void*>, 735 is_convertible<_Up, const volatile void*>>; 736 }; 737 #endif // C++14 738 /** @} */ 739 740 // 20.3.4 logical operations 741 /** @defgroup logical_functors Boolean Operations Classes 742 * @ingroup functors 743 * 744 * Here are wrapper functors for Boolean operations: @c &&, @c ||, 745 * and @c !. 746 * 747 * @{ 748 */ 749 #if __cplusplus > 201103L 750 template<typename _Tp = void> 751 struct logical_and; 752 753 template<typename _Tp = void> 754 struct logical_or; 755 756 template<typename _Tp = void> 757 struct logical_not; 758 #endif 759 760 /// One of the @link logical_functors Boolean operations functors@endlink. 761 template<typename _Tp> 762 struct logical_and : public binary_function<_Tp, _Tp, bool> 763 { 764 _GLIBCXX14_CONSTEXPR 765 bool 766 operator()(const _Tp& __x, const _Tp& __y) const 767 { return __x && __y; } 768 }; 769 770 /// One of the @link logical_functors Boolean operations functors@endlink. 771 template<typename _Tp> 772 struct logical_or : public binary_function<_Tp, _Tp, bool> 773 { 774 _GLIBCXX14_CONSTEXPR 775 bool 776 operator()(const _Tp& __x, const _Tp& __y) const 777 { return __x || __y; } 778 }; 779 780 /// One of the @link logical_functors Boolean operations functors@endlink. 781 template<typename _Tp> 782 struct logical_not : public unary_function<_Tp, bool> 783 { 784 _GLIBCXX14_CONSTEXPR 785 bool 786 operator()(const _Tp& __x) const 787 { return !__x; } 788 }; 789 790 #if __cplusplus > 201103L 791 /// One of the @link logical_functors Boolean operations functors@endlink. 792 template<> 793 struct logical_and<void> 794 { 795 template <typename _Tp, typename _Up> 796 _GLIBCXX14_CONSTEXPR 797 auto 798 operator()(_Tp&& __t, _Up&& __u) const 799 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u))) 800 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u)) 801 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); } 802 803 typedef __is_transparent is_transparent; 804 }; 805 806 /// One of the @link logical_functors Boolean operations functors@endlink. 807 template<> 808 struct logical_or<void> 809 { 810 template <typename _Tp, typename _Up> 811 _GLIBCXX14_CONSTEXPR 812 auto 813 operator()(_Tp&& __t, _Up&& __u) const 814 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u))) 815 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u)) 816 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); } 817 818 typedef __is_transparent is_transparent; 819 }; 820 821 /// One of the @link logical_functors Boolean operations functors@endlink. 822 template<> 823 struct logical_not<void> 824 { 825 template <typename _Tp> 826 _GLIBCXX14_CONSTEXPR 827 auto 828 operator()(_Tp&& __t) const 829 noexcept(noexcept(!std::forward<_Tp>(__t))) 830 -> decltype(!std::forward<_Tp>(__t)) 831 { return !std::forward<_Tp>(__t); } 832 833 typedef __is_transparent is_transparent; 834 }; 835 #endif 836 /** @} */ 837 838 #if __cplusplus > 201103L 839 template<typename _Tp = void> 840 struct bit_and; 841 842 template<typename _Tp = void> 843 struct bit_or; 844 845 template<typename _Tp = void> 846 struct bit_xor; 847 848 template<typename _Tp = void> 849 struct bit_not; 850 #endif 851 852 // _GLIBCXX_RESOLVE_LIB_DEFECTS 853 // DR 660. Missing Bitwise Operations. 854 template<typename _Tp> 855 struct bit_and : public binary_function<_Tp, _Tp, _Tp> 856 { 857 _GLIBCXX14_CONSTEXPR 858 _Tp 859 operator()(const _Tp& __x, const _Tp& __y) const 860 { return __x & __y; } 861 }; 862 863 template<typename _Tp> 864 struct bit_or : public binary_function<_Tp, _Tp, _Tp> 865 { 866 _GLIBCXX14_CONSTEXPR 867 _Tp 868 operator()(const _Tp& __x, const _Tp& __y) const 869 { return __x | __y; } 870 }; 871 872 template<typename _Tp> 873 struct bit_xor : public binary_function<_Tp, _Tp, _Tp> 874 { 875 _GLIBCXX14_CONSTEXPR 876 _Tp 877 operator()(const _Tp& __x, const _Tp& __y) const 878 { return __x ^ __y; } 879 }; 880 881 template<typename _Tp> 882 struct bit_not : public unary_function<_Tp, _Tp> 883 { 884 _GLIBCXX14_CONSTEXPR 885 _Tp 886 operator()(const _Tp& __x) const 887 { return ~__x; } 888 }; 889 890 #if __cplusplus > 201103L 891 template <> 892 struct bit_and<void> 893 { 894 template <typename _Tp, typename _Up> 895 _GLIBCXX14_CONSTEXPR 896 auto 897 operator()(_Tp&& __t, _Up&& __u) const 898 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u))) 899 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u)) 900 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); } 901 902 typedef __is_transparent is_transparent; 903 }; 904 905 template <> 906 struct bit_or<void> 907 { 908 template <typename _Tp, typename _Up> 909 _GLIBCXX14_CONSTEXPR 910 auto 911 operator()(_Tp&& __t, _Up&& __u) const 912 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u))) 913 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u)) 914 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); } 915 916 typedef __is_transparent is_transparent; 917 }; 918 919 template <> 920 struct bit_xor<void> 921 { 922 template <typename _Tp, typename _Up> 923 _GLIBCXX14_CONSTEXPR 924 auto 925 operator()(_Tp&& __t, _Up&& __u) const 926 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))) 927 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)) 928 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); } 929 930 typedef __is_transparent is_transparent; 931 }; 932 933 template <> 934 struct bit_not<void> 935 { 936 template <typename _Tp> 937 _GLIBCXX14_CONSTEXPR 938 auto 939 operator()(_Tp&& __t) const 940 noexcept(noexcept(~std::forward<_Tp>(__t))) 941 -> decltype(~std::forward<_Tp>(__t)) 942 { return ~std::forward<_Tp>(__t); } 943 944 typedef __is_transparent is_transparent; 945 }; 946 #endif 947 948 // 20.3.5 negators 949 /** @defgroup negators Negators 950 * @ingroup functors 951 * 952 * The functions @c not1 and @c not2 each take a predicate functor 953 * and return an instance of @c unary_negate or 954 * @c binary_negate, respectively. These classes are functors whose 955 * @c operator() performs the stored predicate function and then returns 956 * the negation of the result. 957 * 958 * For example, given a vector of integers and a trivial predicate, 959 * \code 960 * struct IntGreaterThanThree 961 * : public std::unary_function<int, bool> 962 * { 963 * bool operator() (int x) { return x > 3; } 964 * }; 965 * 966 * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree())); 967 * \endcode 968 * The call to @c find_if will locate the first index (i) of @c v for which 969 * <code>!(v[i] > 3)</code> is true. 970 * 971 * The not1/unary_negate combination works on predicates taking a single 972 * argument. The not2/binary_negate combination works on predicates which 973 * take two arguments. 974 * 975 * @{ 976 */ 977 /// One of the @link negators negation functors@endlink. 978 template<typename _Predicate> 979 class unary_negate 980 : public unary_function<typename _Predicate::argument_type, bool> 981 { 982 protected: 983 _Predicate _M_pred; 984 985 public: 986 _GLIBCXX14_CONSTEXPR 987 explicit 988 unary_negate(const _Predicate& __x) : _M_pred(__x) { } 989 990 _GLIBCXX14_CONSTEXPR 991 bool 992 operator()(const typename _Predicate::argument_type& __x) const 993 { return !_M_pred(__x); } 994 }; 995 996 /// One of the @link negators negation functors@endlink. 997 template<typename _Predicate> 998 _GLIBCXX14_CONSTEXPR 999 inline unary_negate<_Predicate> 1000 not1(const _Predicate& __pred) 1001 { return unary_negate<_Predicate>(__pred); } 1002 1003 /// One of the @link negators negation functors@endlink. 1004 template<typename _Predicate> 1005 class binary_negate 1006 : public binary_function<typename _Predicate::first_argument_type, 1007 typename _Predicate::second_argument_type, bool> 1008 { 1009 protected: 1010 _Predicate _M_pred; 1011 1012 public: 1013 _GLIBCXX14_CONSTEXPR 1014 explicit 1015 binary_negate(const _Predicate& __x) : _M_pred(__x) { } 1016 1017 _GLIBCXX14_CONSTEXPR 1018 bool 1019 operator()(const typename _Predicate::first_argument_type& __x, 1020 const typename _Predicate::second_argument_type& __y) const 1021 { return !_M_pred(__x, __y); } 1022 }; 1023 1024 /// One of the @link negators negation functors@endlink. 1025 template<typename _Predicate> 1026 _GLIBCXX14_CONSTEXPR 1027 inline binary_negate<_Predicate> 1028 not2(const _Predicate& __pred) 1029 { return binary_negate<_Predicate>(__pred); } 1030 /** @} */ 1031 1032 // 20.3.7 adaptors pointers functions 1033 /** @defgroup pointer_adaptors Adaptors for pointers to functions 1034 * @ingroup functors 1035 * 1036 * The advantage of function objects over pointers to functions is that 1037 * the objects in the standard library declare nested typedefs describing 1038 * their argument and result types with uniform names (e.g., @c result_type 1039 * from the base classes @c unary_function and @c binary_function). 1040 * Sometimes those typedefs are required, not just optional. 1041 * 1042 * Adaptors are provided to turn pointers to unary (single-argument) and 1043 * binary (double-argument) functions into function objects. The 1044 * long-winded functor @c pointer_to_unary_function is constructed with a 1045 * function pointer @c f, and its @c operator() called with argument @c x 1046 * returns @c f(x). The functor @c pointer_to_binary_function does the same 1047 * thing, but with a double-argument @c f and @c operator(). 1048 * 1049 * The function @c ptr_fun takes a pointer-to-function @c f and constructs 1050 * an instance of the appropriate functor. 1051 * 1052 * @{ 1053 */ 1054 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 1055 template<typename _Arg, typename _Result> 1056 class pointer_to_unary_function : public unary_function<_Arg, _Result> 1057 { 1058 protected: 1059 _Result (*_M_ptr)(_Arg); 1060 1061 public: 1062 pointer_to_unary_function() { } 1063 1064 explicit 1065 pointer_to_unary_function(_Result (*__x)(_Arg)) 1066 : _M_ptr(__x) { } 1067 1068 _Result 1069 operator()(_Arg __x) const 1070 { return _M_ptr(__x); } 1071 }; 1072 1073 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 1074 template<typename _Arg, typename _Result> 1075 inline pointer_to_unary_function<_Arg, _Result> 1076 ptr_fun(_Result (*__x)(_Arg)) 1077 { return pointer_to_unary_function<_Arg, _Result>(__x); } 1078 1079 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 1080 template<typename _Arg1, typename _Arg2, typename _Result> 1081 class pointer_to_binary_function 1082 : public binary_function<_Arg1, _Arg2, _Result> 1083 { 1084 protected: 1085 _Result (*_M_ptr)(_Arg1, _Arg2); 1086 1087 public: 1088 pointer_to_binary_function() { } 1089 1090 explicit 1091 pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) 1092 : _M_ptr(__x) { } 1093 1094 _Result 1095 operator()(_Arg1 __x, _Arg2 __y) const 1096 { return _M_ptr(__x, __y); } 1097 }; 1098 1099 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 1100 template<typename _Arg1, typename _Arg2, typename _Result> 1101 inline pointer_to_binary_function<_Arg1, _Arg2, _Result> 1102 ptr_fun(_Result (*__x)(_Arg1, _Arg2)) 1103 { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } 1104 /** @} */ 1105 1106 template<typename _Tp> 1107 struct _Identity 1108 : public unary_function<_Tp, _Tp> 1109 { 1110 _Tp& 1111 operator()(_Tp& __x) const 1112 { return __x; } 1113 1114 const _Tp& 1115 operator()(const _Tp& __x) const 1116 { return __x; } 1117 }; 1118 1119 // Partial specialization, avoids confusing errors in e.g. std::set<const T>. 1120 template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { }; 1121 1122 template<typename _Pair> 1123 struct _Select1st 1124 : public unary_function<_Pair, typename _Pair::first_type> 1125 { 1126 typename _Pair::first_type& 1127 operator()(_Pair& __x) const 1128 { return __x.first; } 1129 1130 const typename _Pair::first_type& 1131 operator()(const _Pair& __x) const 1132 { return __x.first; } 1133 1134 #if __cplusplus >= 201103L 1135 template<typename _Pair2> 1136 typename _Pair2::first_type& 1137 operator()(_Pair2& __x) const 1138 { return __x.first; } 1139 1140 template<typename _Pair2> 1141 const typename _Pair2::first_type& 1142 operator()(const _Pair2& __x) const 1143 { return __x.first; } 1144 #endif 1145 }; 1146 1147 template<typename _Pair> 1148 struct _Select2nd 1149 : public unary_function<_Pair, typename _Pair::second_type> 1150 { 1151 typename _Pair::second_type& 1152 operator()(_Pair& __x) const 1153 { return __x.second; } 1154 1155 const typename _Pair::second_type& 1156 operator()(const _Pair& __x) const 1157 { return __x.second; } 1158 }; 1159 1160 // 20.3.8 adaptors pointers members 1161 /** @defgroup memory_adaptors Adaptors for pointers to members 1162 * @ingroup functors 1163 * 1164 * There are a total of 8 = 2^3 function objects in this family. 1165 * (1) Member functions taking no arguments vs member functions taking 1166 * one argument. 1167 * (2) Call through pointer vs call through reference. 1168 * (3) Const vs non-const member function. 1169 * 1170 * All of this complexity is in the function objects themselves. You can 1171 * ignore it by using the helper function mem_fun and mem_fun_ref, 1172 * which create whichever type of adaptor is appropriate. 1173 * 1174 * @{ 1175 */ 1176 /// One of the @link memory_adaptors adaptors for member 1177 /// pointers@endlink. 1178 template<typename _Ret, typename _Tp> 1179 class mem_fun_t : public unary_function<_Tp*, _Ret> 1180 { 1181 public: 1182 explicit 1183 mem_fun_t(_Ret (_Tp::*__pf)()) 1184 : _M_f(__pf) { } 1185 1186 _Ret 1187 operator()(_Tp* __p) const 1188 { return (__p->*_M_f)(); } 1189 1190 private: 1191 _Ret (_Tp::*_M_f)(); 1192 }; 1193 1194 /// One of the @link memory_adaptors adaptors for member 1195 /// pointers@endlink. 1196 template<typename _Ret, typename _Tp> 1197 class const_mem_fun_t : public unary_function<const _Tp*, _Ret> 1198 { 1199 public: 1200 explicit 1201 const_mem_fun_t(_Ret (_Tp::*__pf)() const) 1202 : _M_f(__pf) { } 1203 1204 _Ret 1205 operator()(const _Tp* __p) const 1206 { return (__p->*_M_f)(); } 1207 1208 private: 1209 _Ret (_Tp::*_M_f)() const; 1210 }; 1211 1212 /// One of the @link memory_adaptors adaptors for member 1213 /// pointers@endlink. 1214 template<typename _Ret, typename _Tp> 1215 class mem_fun_ref_t : public unary_function<_Tp, _Ret> 1216 { 1217 public: 1218 explicit 1219 mem_fun_ref_t(_Ret (_Tp::*__pf)()) 1220 : _M_f(__pf) { } 1221 1222 _Ret 1223 operator()(_Tp& __r) const 1224 { return (__r.*_M_f)(); } 1225 1226 private: 1227 _Ret (_Tp::*_M_f)(); 1228 }; 1229 1230 /// One of the @link memory_adaptors adaptors for member 1231 /// pointers@endlink. 1232 template<typename _Ret, typename _Tp> 1233 class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> 1234 { 1235 public: 1236 explicit 1237 const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) 1238 : _M_f(__pf) { } 1239 1240 _Ret 1241 operator()(const _Tp& __r) const 1242 { return (__r.*_M_f)(); } 1243 1244 private: 1245 _Ret (_Tp::*_M_f)() const; 1246 }; 1247 1248 /// One of the @link memory_adaptors adaptors for member 1249 /// pointers@endlink. 1250 template<typename _Ret, typename _Tp, typename _Arg> 1251 class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> 1252 { 1253 public: 1254 explicit 1255 mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) 1256 : _M_f(__pf) { } 1257 1258 _Ret 1259 operator()(_Tp* __p, _Arg __x) const 1260 { return (__p->*_M_f)(__x); } 1261 1262 private: 1263 _Ret (_Tp::*_M_f)(_Arg); 1264 }; 1265 1266 /// One of the @link memory_adaptors adaptors for member 1267 /// pointers@endlink. 1268 template<typename _Ret, typename _Tp, typename _Arg> 1269 class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> 1270 { 1271 public: 1272 explicit 1273 const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) 1274 : _M_f(__pf) { } 1275 1276 _Ret 1277 operator()(const _Tp* __p, _Arg __x) const 1278 { return (__p->*_M_f)(__x); } 1279 1280 private: 1281 _Ret (_Tp::*_M_f)(_Arg) const; 1282 }; 1283 1284 /// One of the @link memory_adaptors adaptors for member 1285 /// pointers@endlink. 1286 template<typename _Ret, typename _Tp, typename _Arg> 1287 class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> 1288 { 1289 public: 1290 explicit 1291 mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) 1292 : _M_f(__pf) { } 1293 1294 _Ret 1295 operator()(_Tp& __r, _Arg __x) const 1296 { return (__r.*_M_f)(__x); } 1297 1298 private: 1299 _Ret (_Tp::*_M_f)(_Arg); 1300 }; 1301 1302 /// One of the @link memory_adaptors adaptors for member 1303 /// pointers@endlink. 1304 template<typename _Ret, typename _Tp, typename _Arg> 1305 class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> 1306 { 1307 public: 1308 explicit 1309 const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) 1310 : _M_f(__pf) { } 1311 1312 _Ret 1313 operator()(const _Tp& __r, _Arg __x) const 1314 { return (__r.*_M_f)(__x); } 1315 1316 private: 1317 _Ret (_Tp::*_M_f)(_Arg) const; 1318 }; 1319 1320 // Mem_fun adaptor helper functions. There are only two: 1321 // mem_fun and mem_fun_ref. 1322 template<typename _Ret, typename _Tp> 1323 inline mem_fun_t<_Ret, _Tp> 1324 mem_fun(_Ret (_Tp::*__f)()) 1325 { return mem_fun_t<_Ret, _Tp>(__f); } 1326 1327 template<typename _Ret, typename _Tp> 1328 inline const_mem_fun_t<_Ret, _Tp> 1329 mem_fun(_Ret (_Tp::*__f)() const) 1330 { return const_mem_fun_t<_Ret, _Tp>(__f); } 1331 1332 template<typename _Ret, typename _Tp> 1333 inline mem_fun_ref_t<_Ret, _Tp> 1334 mem_fun_ref(_Ret (_Tp::*__f)()) 1335 { return mem_fun_ref_t<_Ret, _Tp>(__f); } 1336 1337 template<typename _Ret, typename _Tp> 1338 inline const_mem_fun_ref_t<_Ret, _Tp> 1339 mem_fun_ref(_Ret (_Tp::*__f)() const) 1340 { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } 1341 1342 template<typename _Ret, typename _Tp, typename _Arg> 1343 inline mem_fun1_t<_Ret, _Tp, _Arg> 1344 mem_fun(_Ret (_Tp::*__f)(_Arg)) 1345 { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } 1346 1347 template<typename _Ret, typename _Tp, typename _Arg> 1348 inline const_mem_fun1_t<_Ret, _Tp, _Arg> 1349 mem_fun(_Ret (_Tp::*__f)(_Arg) const) 1350 { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } 1351 1352 template<typename _Ret, typename _Tp, typename _Arg> 1353 inline mem_fun1_ref_t<_Ret, _Tp, _Arg> 1354 mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) 1355 { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } 1356 1357 template<typename _Ret, typename _Tp, typename _Arg> 1358 inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> 1359 mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) 1360 { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } 1361 1362 /** @} */ 1363 1364 _GLIBCXX_END_NAMESPACE_VERSION 1365 } // namespace 1366 1367 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED 1368 # include <backward/binders.h> 1369 #endif 1370 1371 #endif /* _STL_FUNCTION_H */ 1372