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