1 // Functor implementations -*- C++ -*- 2 3 // Copyright (C) 2001-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 /* 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 namespace std _GLIBCXX_VISIBILITY(default) 60 { 61 _GLIBCXX_BEGIN_NAMESPACE_VERSION 62 63 // 20.3.1 base classes 64 /** @defgroup functors Function Objects 65 * @ingroup utilities 66 * 67 * Function objects, or @e functors, are objects with an @c operator() 68 * defined and accessible. They can be passed as arguments to algorithm 69 * templates and used in place of a function pointer. Not only is the 70 * resulting expressiveness of the library increased, but the generated 71 * code can be more efficient than what you might write by hand. When we 72 * refer to @a functors, then, generally we include function pointers in 73 * the description as well. 74 * 75 * Often, functors are only created as temporaries passed to algorithm 76 * calls, rather than being created as named variables. 77 * 78 * Two examples taken from the standard itself follow. To perform a 79 * by-element addition of two vectors @c a and @c b containing @c double, 80 * and put the result in @c a, use 81 * \code 82 * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>()); 83 * \endcode 84 * To negate every element in @c a, use 85 * \code 86 * transform(a.begin(), a.end(), a.begin(), negate<double>()); 87 * \endcode 88 * The addition and negation functions will be inlined directly. 89 * 90 * The standard functors are derived from structs named @c unary_function 91 * and @c binary_function. These two classes contain nothing but typedefs, 92 * to aid in generic (template) programming. If you write your own 93 * functors, you might consider doing the same. 94 * 95 * @{ 96 */ 97 /** 98 * This is one of the @link functors functor base classes@endlink. 99 */ 100 template<typename _Arg, typename _Result> 101 struct unary_function 102 { 103 /// @c argument_type is the type of the argument 104 typedef _Arg argument_type; 105 106 /// @c result_type is the return type 107 typedef _Result result_type; 108 }; 109 110 /** 111 * This is one of the @link functors functor base classes@endlink. 112 */ 113 template<typename _Arg1, typename _Arg2, typename _Result> 114 struct binary_function 115 { 116 /// @c first_argument_type is the type of the first argument 117 typedef _Arg1 first_argument_type; 118 119 /// @c second_argument_type is the type of the second argument 120 typedef _Arg2 second_argument_type; 121 122 /// @c result_type is the return type 123 typedef _Result result_type; 124 }; 125 /** @} */ 126 127 // 20.3.2 arithmetic 128 /** @defgroup arithmetic_functors Arithmetic Classes 129 * @ingroup functors 130 * 131 * Because basic math often needs to be done during an algorithm, 132 * the library provides functors for those operations. See the 133 * documentation for @link functors the base classes@endlink 134 * for examples of their use. 135 * 136 * @{ 137 */ 138 /// One of the @link arithmetic_functors math functors@endlink. 139 template<typename _Tp> 140 struct plus : public binary_function<_Tp, _Tp, _Tp> 141 { 142 _Tp 143 operator()(const _Tp& __x, const _Tp& __y) const 144 { return __x + __y; } 145 }; 146 147 /// One of the @link arithmetic_functors math functors@endlink. 148 template<typename _Tp> 149 struct minus : public binary_function<_Tp, _Tp, _Tp> 150 { 151 _Tp 152 operator()(const _Tp& __x, const _Tp& __y) const 153 { return __x - __y; } 154 }; 155 156 /// One of the @link arithmetic_functors math functors@endlink. 157 template<typename _Tp> 158 struct multiplies : public binary_function<_Tp, _Tp, _Tp> 159 { 160 _Tp 161 operator()(const _Tp& __x, const _Tp& __y) const 162 { return __x * __y; } 163 }; 164 165 /// One of the @link arithmetic_functors math functors@endlink. 166 template<typename _Tp> 167 struct divides : public binary_function<_Tp, _Tp, _Tp> 168 { 169 _Tp 170 operator()(const _Tp& __x, const _Tp& __y) const 171 { return __x / __y; } 172 }; 173 174 /// One of the @link arithmetic_functors math functors@endlink. 175 template<typename _Tp> 176 struct modulus : public binary_function<_Tp, _Tp, _Tp> 177 { 178 _Tp 179 operator()(const _Tp& __x, const _Tp& __y) const 180 { return __x % __y; } 181 }; 182 183 /// One of the @link arithmetic_functors math functors@endlink. 184 template<typename _Tp> 185 struct negate : public unary_function<_Tp, _Tp> 186 { 187 _Tp 188 operator()(const _Tp& __x) const 189 { return -__x; } 190 }; 191 /** @} */ 192 193 // 20.3.3 comparisons 194 /** @defgroup comparison_functors Comparison Classes 195 * @ingroup functors 196 * 197 * The library provides six wrapper functors for all the basic comparisons 198 * in C++, like @c <. 199 * 200 * @{ 201 */ 202 /// One of the @link comparison_functors comparison functors@endlink. 203 template<typename _Tp> 204 struct equal_to : public binary_function<_Tp, _Tp, bool> 205 { 206 bool 207 operator()(const _Tp& __x, const _Tp& __y) const 208 { return __x == __y; } 209 }; 210 211 /// One of the @link comparison_functors comparison functors@endlink. 212 template<typename _Tp> 213 struct not_equal_to : public binary_function<_Tp, _Tp, bool> 214 { 215 bool 216 operator()(const _Tp& __x, const _Tp& __y) const 217 { return __x != __y; } 218 }; 219 220 /// One of the @link comparison_functors comparison functors@endlink. 221 template<typename _Tp> 222 struct greater : public binary_function<_Tp, _Tp, bool> 223 { 224 bool 225 operator()(const _Tp& __x, const _Tp& __y) const 226 { return __x > __y; } 227 }; 228 229 /// One of the @link comparison_functors comparison functors@endlink. 230 template<typename _Tp> 231 struct less : public binary_function<_Tp, _Tp, bool> 232 { 233 bool 234 operator()(const _Tp& __x, const _Tp& __y) const 235 { return __x < __y; } 236 }; 237 238 /// One of the @link comparison_functors comparison functors@endlink. 239 template<typename _Tp> 240 struct greater_equal : public binary_function<_Tp, _Tp, bool> 241 { 242 bool 243 operator()(const _Tp& __x, const _Tp& __y) const 244 { return __x >= __y; } 245 }; 246 247 /// One of the @link comparison_functors comparison functors@endlink. 248 template<typename _Tp> 249 struct less_equal : public binary_function<_Tp, _Tp, bool> 250 { 251 bool 252 operator()(const _Tp& __x, const _Tp& __y) const 253 { return __x <= __y; } 254 }; 255 /** @} */ 256 257 // 20.3.4 logical operations 258 /** @defgroup logical_functors Boolean Operations Classes 259 * @ingroup functors 260 * 261 * Here are wrapper functors for Boolean operations: @c &&, @c ||, 262 * and @c !. 263 * 264 * @{ 265 */ 266 /// One of the @link logical_functors Boolean operations functors@endlink. 267 template<typename _Tp> 268 struct logical_and : public binary_function<_Tp, _Tp, bool> 269 { 270 bool 271 operator()(const _Tp& __x, const _Tp& __y) const 272 { return __x && __y; } 273 }; 274 275 /// One of the @link logical_functors Boolean operations functors@endlink. 276 template<typename _Tp> 277 struct logical_or : public binary_function<_Tp, _Tp, bool> 278 { 279 bool 280 operator()(const _Tp& __x, const _Tp& __y) const 281 { return __x || __y; } 282 }; 283 284 /// One of the @link logical_functors Boolean operations functors@endlink. 285 template<typename _Tp> 286 struct logical_not : public unary_function<_Tp, bool> 287 { 288 bool 289 operator()(const _Tp& __x) const 290 { return !__x; } 291 }; 292 /** @} */ 293 294 // _GLIBCXX_RESOLVE_LIB_DEFECTS 295 // DR 660. Missing Bitwise Operations. 296 template<typename _Tp> 297 struct bit_and : public binary_function<_Tp, _Tp, _Tp> 298 { 299 _Tp 300 operator()(const _Tp& __x, const _Tp& __y) const 301 { return __x & __y; } 302 }; 303 304 template<typename _Tp> 305 struct bit_or : public binary_function<_Tp, _Tp, _Tp> 306 { 307 _Tp 308 operator()(const _Tp& __x, const _Tp& __y) const 309 { return __x | __y; } 310 }; 311 312 template<typename _Tp> 313 struct bit_xor : public binary_function<_Tp, _Tp, _Tp> 314 { 315 _Tp 316 operator()(const _Tp& __x, const _Tp& __y) const 317 { return __x ^ __y; } 318 }; 319 320 // 20.3.5 negators 321 /** @defgroup negators Negators 322 * @ingroup functors 323 * 324 * The functions @c not1 and @c not2 each take a predicate functor 325 * and return an instance of @c unary_negate or 326 * @c binary_negate, respectively. These classes are functors whose 327 * @c operator() performs the stored predicate function and then returns 328 * the negation of the result. 329 * 330 * For example, given a vector of integers and a trivial predicate, 331 * \code 332 * struct IntGreaterThanThree 333 * : public std::unary_function<int, bool> 334 * { 335 * bool operator() (int x) { return x > 3; } 336 * }; 337 * 338 * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree())); 339 * \endcode 340 * The call to @c find_if will locate the first index (i) of @c v for which 341 * <code>!(v[i] > 3)</code> is true. 342 * 343 * The not1/unary_negate combination works on predicates taking a single 344 * argument. The not2/binary_negate combination works on predicates which 345 * take two arguments. 346 * 347 * @{ 348 */ 349 /// One of the @link negators negation functors@endlink. 350 template<typename _Predicate> 351 class unary_negate 352 : public unary_function<typename _Predicate::argument_type, bool> 353 { 354 protected: 355 _Predicate _M_pred; 356 357 public: 358 explicit 359 unary_negate(const _Predicate& __x) : _M_pred(__x) { } 360 361 bool 362 operator()(const typename _Predicate::argument_type& __x) const 363 { return !_M_pred(__x); } 364 }; 365 366 /// One of the @link negators negation functors@endlink. 367 template<typename _Predicate> 368 inline unary_negate<_Predicate> 369 not1(const _Predicate& __pred) 370 { return unary_negate<_Predicate>(__pred); } 371 372 /// One of the @link negators negation functors@endlink. 373 template<typename _Predicate> 374 class binary_negate 375 : public binary_function<typename _Predicate::first_argument_type, 376 typename _Predicate::second_argument_type, bool> 377 { 378 protected: 379 _Predicate _M_pred; 380 381 public: 382 explicit 383 binary_negate(const _Predicate& __x) : _M_pred(__x) { } 384 385 bool 386 operator()(const typename _Predicate::first_argument_type& __x, 387 const typename _Predicate::second_argument_type& __y) const 388 { return !_M_pred(__x, __y); } 389 }; 390 391 /// One of the @link negators negation functors@endlink. 392 template<typename _Predicate> 393 inline binary_negate<_Predicate> 394 not2(const _Predicate& __pred) 395 { return binary_negate<_Predicate>(__pred); } 396 /** @} */ 397 398 // 20.3.7 adaptors pointers functions 399 /** @defgroup pointer_adaptors Adaptors for pointers to functions 400 * @ingroup functors 401 * 402 * The advantage of function objects over pointers to functions is that 403 * the objects in the standard library declare nested typedefs describing 404 * their argument and result types with uniform names (e.g., @c result_type 405 * from the base classes @c unary_function and @c binary_function). 406 * Sometimes those typedefs are required, not just optional. 407 * 408 * Adaptors are provided to turn pointers to unary (single-argument) and 409 * binary (double-argument) functions into function objects. The 410 * long-winded functor @c pointer_to_unary_function is constructed with a 411 * function pointer @c f, and its @c operator() called with argument @c x 412 * returns @c f(x). The functor @c pointer_to_binary_function does the same 413 * thing, but with a double-argument @c f and @c operator(). 414 * 415 * The function @c ptr_fun takes a pointer-to-function @c f and constructs 416 * an instance of the appropriate functor. 417 * 418 * @{ 419 */ 420 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 421 template<typename _Arg, typename _Result> 422 class pointer_to_unary_function : public unary_function<_Arg, _Result> 423 { 424 protected: 425 _Result (*_M_ptr)(_Arg); 426 427 public: 428 pointer_to_unary_function() { } 429 430 explicit 431 pointer_to_unary_function(_Result (*__x)(_Arg)) 432 : _M_ptr(__x) { } 433 434 _Result 435 operator()(_Arg __x) const 436 { return _M_ptr(__x); } 437 }; 438 439 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 440 template<typename _Arg, typename _Result> 441 inline pointer_to_unary_function<_Arg, _Result> 442 ptr_fun(_Result (*__x)(_Arg)) 443 { return pointer_to_unary_function<_Arg, _Result>(__x); } 444 445 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 446 template<typename _Arg1, typename _Arg2, typename _Result> 447 class pointer_to_binary_function 448 : public binary_function<_Arg1, _Arg2, _Result> 449 { 450 protected: 451 _Result (*_M_ptr)(_Arg1, _Arg2); 452 453 public: 454 pointer_to_binary_function() { } 455 456 explicit 457 pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) 458 : _M_ptr(__x) { } 459 460 _Result 461 operator()(_Arg1 __x, _Arg2 __y) const 462 { return _M_ptr(__x, __y); } 463 }; 464 465 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 466 template<typename _Arg1, typename _Arg2, typename _Result> 467 inline pointer_to_binary_function<_Arg1, _Arg2, _Result> 468 ptr_fun(_Result (*__x)(_Arg1, _Arg2)) 469 { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } 470 /** @} */ 471 472 template<typename _Tp> 473 struct _Identity 474 : public unary_function<_Tp,_Tp> 475 { 476 _Tp& 477 operator()(_Tp& __x) const 478 { return __x; } 479 480 const _Tp& 481 operator()(const _Tp& __x) const 482 { return __x; } 483 }; 484 485 template<typename _Pair> 486 struct _Select1st 487 : public unary_function<_Pair, typename _Pair::first_type> 488 { 489 typename _Pair::first_type& 490 operator()(_Pair& __x) const 491 { return __x.first; } 492 493 const typename _Pair::first_type& 494 operator()(const _Pair& __x) const 495 { return __x.first; } 496 497 #if __cplusplus >= 201103L 498 template<typename _Pair2> 499 typename _Pair2::first_type& 500 operator()(_Pair2& __x) const 501 { return __x.first; } 502 503 template<typename _Pair2> 504 const typename _Pair2::first_type& 505 operator()(const _Pair2& __x) const 506 { return __x.first; } 507 #endif 508 }; 509 510 template<typename _Pair> 511 struct _Select2nd 512 : public unary_function<_Pair, typename _Pair::second_type> 513 { 514 typename _Pair::second_type& 515 operator()(_Pair& __x) const 516 { return __x.second; } 517 518 const typename _Pair::second_type& 519 operator()(const _Pair& __x) const 520 { return __x.second; } 521 }; 522 523 // 20.3.8 adaptors pointers members 524 /** @defgroup memory_adaptors Adaptors for pointers to members 525 * @ingroup functors 526 * 527 * There are a total of 8 = 2^3 function objects in this family. 528 * (1) Member functions taking no arguments vs member functions taking 529 * one argument. 530 * (2) Call through pointer vs call through reference. 531 * (3) Const vs non-const member function. 532 * 533 * All of this complexity is in the function objects themselves. You can 534 * ignore it by using the helper function mem_fun and mem_fun_ref, 535 * which create whichever type of adaptor is appropriate. 536 * 537 * @{ 538 */ 539 /// One of the @link memory_adaptors adaptors for member 540 /// pointers@endlink. 541 template<typename _Ret, typename _Tp> 542 class mem_fun_t : public unary_function<_Tp*, _Ret> 543 { 544 public: 545 explicit 546 mem_fun_t(_Ret (_Tp::*__pf)()) 547 : _M_f(__pf) { } 548 549 _Ret 550 operator()(_Tp* __p) const 551 { return (__p->*_M_f)(); } 552 553 private: 554 _Ret (_Tp::*_M_f)(); 555 }; 556 557 /// One of the @link memory_adaptors adaptors for member 558 /// pointers@endlink. 559 template<typename _Ret, typename _Tp> 560 class const_mem_fun_t : public unary_function<const _Tp*, _Ret> 561 { 562 public: 563 explicit 564 const_mem_fun_t(_Ret (_Tp::*__pf)() const) 565 : _M_f(__pf) { } 566 567 _Ret 568 operator()(const _Tp* __p) const 569 { return (__p->*_M_f)(); } 570 571 private: 572 _Ret (_Tp::*_M_f)() const; 573 }; 574 575 /// One of the @link memory_adaptors adaptors for member 576 /// pointers@endlink. 577 template<typename _Ret, typename _Tp> 578 class mem_fun_ref_t : public unary_function<_Tp, _Ret> 579 { 580 public: 581 explicit 582 mem_fun_ref_t(_Ret (_Tp::*__pf)()) 583 : _M_f(__pf) { } 584 585 _Ret 586 operator()(_Tp& __r) const 587 { return (__r.*_M_f)(); } 588 589 private: 590 _Ret (_Tp::*_M_f)(); 591 }; 592 593 /// One of the @link memory_adaptors adaptors for member 594 /// pointers@endlink. 595 template<typename _Ret, typename _Tp> 596 class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> 597 { 598 public: 599 explicit 600 const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) 601 : _M_f(__pf) { } 602 603 _Ret 604 operator()(const _Tp& __r) const 605 { return (__r.*_M_f)(); } 606 607 private: 608 _Ret (_Tp::*_M_f)() const; 609 }; 610 611 /// One of the @link memory_adaptors adaptors for member 612 /// pointers@endlink. 613 template<typename _Ret, typename _Tp, typename _Arg> 614 class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> 615 { 616 public: 617 explicit 618 mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) 619 : _M_f(__pf) { } 620 621 _Ret 622 operator()(_Tp* __p, _Arg __x) const 623 { return (__p->*_M_f)(__x); } 624 625 private: 626 _Ret (_Tp::*_M_f)(_Arg); 627 }; 628 629 /// One of the @link memory_adaptors adaptors for member 630 /// pointers@endlink. 631 template<typename _Ret, typename _Tp, typename _Arg> 632 class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> 633 { 634 public: 635 explicit 636 const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) 637 : _M_f(__pf) { } 638 639 _Ret 640 operator()(const _Tp* __p, _Arg __x) const 641 { return (__p->*_M_f)(__x); } 642 643 private: 644 _Ret (_Tp::*_M_f)(_Arg) const; 645 }; 646 647 /// One of the @link memory_adaptors adaptors for member 648 /// pointers@endlink. 649 template<typename _Ret, typename _Tp, typename _Arg> 650 class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> 651 { 652 public: 653 explicit 654 mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) 655 : _M_f(__pf) { } 656 657 _Ret 658 operator()(_Tp& __r, _Arg __x) const 659 { return (__r.*_M_f)(__x); } 660 661 private: 662 _Ret (_Tp::*_M_f)(_Arg); 663 }; 664 665 /// One of the @link memory_adaptors adaptors for member 666 /// pointers@endlink. 667 template<typename _Ret, typename _Tp, typename _Arg> 668 class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> 669 { 670 public: 671 explicit 672 const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) 673 : _M_f(__pf) { } 674 675 _Ret 676 operator()(const _Tp& __r, _Arg __x) const 677 { return (__r.*_M_f)(__x); } 678 679 private: 680 _Ret (_Tp::*_M_f)(_Arg) const; 681 }; 682 683 // Mem_fun adaptor helper functions. There are only two: 684 // mem_fun and mem_fun_ref. 685 template<typename _Ret, typename _Tp> 686 inline mem_fun_t<_Ret, _Tp> 687 mem_fun(_Ret (_Tp::*__f)()) 688 { return mem_fun_t<_Ret, _Tp>(__f); } 689 690 template<typename _Ret, typename _Tp> 691 inline const_mem_fun_t<_Ret, _Tp> 692 mem_fun(_Ret (_Tp::*__f)() const) 693 { return const_mem_fun_t<_Ret, _Tp>(__f); } 694 695 template<typename _Ret, typename _Tp> 696 inline mem_fun_ref_t<_Ret, _Tp> 697 mem_fun_ref(_Ret (_Tp::*__f)()) 698 { return mem_fun_ref_t<_Ret, _Tp>(__f); } 699 700 template<typename _Ret, typename _Tp> 701 inline const_mem_fun_ref_t<_Ret, _Tp> 702 mem_fun_ref(_Ret (_Tp::*__f)() const) 703 { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } 704 705 template<typename _Ret, typename _Tp, typename _Arg> 706 inline mem_fun1_t<_Ret, _Tp, _Arg> 707 mem_fun(_Ret (_Tp::*__f)(_Arg)) 708 { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } 709 710 template<typename _Ret, typename _Tp, typename _Arg> 711 inline const_mem_fun1_t<_Ret, _Tp, _Arg> 712 mem_fun(_Ret (_Tp::*__f)(_Arg) const) 713 { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } 714 715 template<typename _Ret, typename _Tp, typename _Arg> 716 inline mem_fun1_ref_t<_Ret, _Tp, _Arg> 717 mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) 718 { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } 719 720 template<typename _Ret, typename _Tp, typename _Arg> 721 inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> 722 mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) 723 { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } 724 725 /** @} */ 726 727 _GLIBCXX_END_NAMESPACE_VERSION 728 } // namespace 729 730 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED 731 # include <backward/binders.h> 732 #endif 733 734 #endif /* _STL_FUNCTION_H */ 735
