1// Functor implementations -*- C++ -*- 2 3// Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011 4// Free Software Foundation, Inc. 5// 6// This file is part of the GNU ISO C++ Library. This library is free 7// software; you can redistribute it and/or modify it under the 8// terms of the GNU General Public License as published by the 9// Free Software Foundation; either version 3, or (at your option) 10// any later version. 11 12// This library is distributed in the hope that it will be useful, 13// but WITHOUT ANY WARRANTY; without even the implied warranty of 14// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15// GNU General Public License for more details. 16 17// Under Section 7 of GPL version 3, you are granted additional 18// permissions described in the GCC Runtime Library Exception, version 19// 3.1, as published by the Free Software Foundation. 20 21// You should have received a copy of the GNU General Public License and 22// a copy of the GCC Runtime Library Exception along with this program; 23// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 24// <http://www.gnu.org/licenses/>. 25 26/* 27 * 28 * Copyright (c) 1994 29 * Hewlett-Packard Company 30 * 31 * Permission to use, copy, modify, distribute and sell this software 32 * and its documentation for any purpose is hereby granted without fee, 33 * provided that the above copyright notice appear in all copies and 34 * that both that copyright notice and this permission notice appear 35 * in supporting documentation. Hewlett-Packard Company makes no 36 * representations about the suitability of this software for any 37 * purpose. It is provided "as is" without express or implied warranty. 38 * 39 * 40 * Copyright (c) 1996-1998 41 * Silicon Graphics Computer Systems, Inc. 42 * 43 * Permission to use, copy, modify, distribute and sell this software 44 * and its documentation for any purpose is hereby granted without fee, 45 * provided that the above copyright notice appear in all copies and 46 * that both that copyright notice and this permission notice appear 47 * in supporting documentation. Silicon Graphics makes no 48 * representations about the suitability of this software for any 49 * purpose. It is provided "as is" without express or implied warranty. 50 */ 51 52/** @file bits/stl_function.h 53 * This is an internal header file, included by other library headers. 54 * Do not attempt to use it directly. @headername{functional} 55 */ 56 57#ifndef _STL_FUNCTION_H 58#define _STL_FUNCTION_H 1 59 60namespace std _GLIBCXX_VISIBILITY(default) 61{ 62_GLIBCXX_BEGIN_NAMESPACE_VERSION 63 64 // 20.3.1 base classes 65 /** @defgroup functors Function Objects 66 * @ingroup utilities 67 * 68 * Function objects, or @e functors, are objects with an @c operator() 69 * defined and accessible. They can be passed as arguments to algorithm 70 * templates and used in place of a function pointer. Not only is the 71 * resulting expressiveness of the library increased, but the generated 72 * code can be more efficient than what you might write by hand. When we 73 * refer to @a functors, then, generally we include function pointers in 74 * the description as well. 75 * 76 * Often, functors are only created as temporaries passed to algorithm 77 * calls, rather than being created as named variables. 78 * 79 * Two examples taken from the standard itself follow. To perform a 80 * by-element addition of two vectors @c a and @c b containing @c double, 81 * and put the result in @c a, use 82 * \code 83 * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>()); 84 * \endcode 85 * To negate every element in @c a, use 86 * \code 87 * transform(a.begin(), a.end(), a.begin(), negate<double>()); 88 * \endcode 89 * The addition and negation functions will be inlined directly. 90 * 91 * The standard functors are derived from structs named @c unary_function 92 * and @c binary_function. These two classes contain nothing but typedefs, 93 * to aid in generic (template) programming. If you write your own 94 * functors, you might consider doing the same. 95 * 96 * @{ 97 */ 98 /** 99 * This is one of the @link functors functor base classes@endlink. 100 */ 101 template<typename _Arg, typename _Result> 102 struct unary_function 103 { 104 /// @c argument_type is the type of the argument 105 typedef _Arg argument_type; 106 107 /// @c result_type is the return type 108 typedef _Result result_type; 109 }; 110 111 /** 112 * This is one of the @link functors functor base classes@endlink. 113 */ 114 template<typename _Arg1, typename _Arg2, typename _Result> 115 struct binary_function 116 { 117 /// @c first_argument_type is the type of the first argument 118 typedef _Arg1 first_argument_type; 119 120 /// @c second_argument_type is the type of the second argument 121 typedef _Arg2 second_argument_type; 122 123 /// @c result_type is the return type 124 typedef _Result result_type; 125 }; 126 /** @} */ 127 128 // 20.3.2 arithmetic 129 /** @defgroup arithmetic_functors Arithmetic Classes 130 * @ingroup functors 131 * 132 * Because basic math often needs to be done during an algorithm, 133 * the library provides functors for those operations. See the 134 * documentation for @link functors the base classes@endlink 135 * for examples of their use. 136 * 137 * @{ 138 */ 139 /// One of the @link arithmetic_functors math functors@endlink. 140 template<typename _Tp> 141 struct plus : public binary_function<_Tp, _Tp, _Tp> 142 { 143 _Tp 144 operator()(const _Tp& __x, const _Tp& __y) const 145 { return __x + __y; } 146 }; 147 148 /// One of the @link arithmetic_functors math functors@endlink. 149 template<typename _Tp> 150 struct minus : public binary_function<_Tp, _Tp, _Tp> 151 { 152 _Tp 153 operator()(const _Tp& __x, const _Tp& __y) const 154 { return __x - __y; } 155 }; 156 157 /// One of the @link arithmetic_functors math functors@endlink. 158 template<typename _Tp> 159 struct multiplies : public binary_function<_Tp, _Tp, _Tp> 160 { 161 _Tp 162 operator()(const _Tp& __x, const _Tp& __y) const 163 { return __x * __y; } 164 }; 165 166 /// One of the @link arithmetic_functors math functors@endlink. 167 template<typename _Tp> 168 struct divides : public binary_function<_Tp, _Tp, _Tp> 169 { 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 modulus : public binary_function<_Tp, _Tp, _Tp> 178 { 179 _Tp 180 operator()(const _Tp& __x, const _Tp& __y) const 181 { return __x % __y; } 182 }; 183 184 /// One of the @link arithmetic_functors math functors@endlink. 185 template<typename _Tp> 186 struct negate : public unary_function<_Tp, _Tp> 187 { 188 _Tp 189 operator()(const _Tp& __x) const 190 { return -__x; } 191 }; 192 /** @} */ 193 194 // 20.3.3 comparisons 195 /** @defgroup comparison_functors Comparison Classes 196 * @ingroup functors 197 * 198 * The library provides six wrapper functors for all the basic comparisons 199 * in C++, like @c <. 200 * 201 * @{ 202 */ 203 /// One of the @link comparison_functors comparison functors@endlink. 204 template<typename _Tp> 205 struct equal_to : public binary_function<_Tp, _Tp, bool> 206 { 207 bool 208 operator()(const _Tp& __x, const _Tp& __y) const 209 { return __x == __y; } 210 }; 211 212 /// One of the @link comparison_functors comparison functors@endlink. 213 template<typename _Tp> 214 struct not_equal_to : public binary_function<_Tp, _Tp, bool> 215 { 216 bool 217 operator()(const _Tp& __x, const _Tp& __y) const 218 { return __x != __y; } 219 }; 220 221 /// One of the @link comparison_functors comparison functors@endlink. 222 template<typename _Tp> 223 struct greater : public binary_function<_Tp, _Tp, bool> 224 { 225 bool 226 operator()(const _Tp& __x, const _Tp& __y) const 227 { return __x > __y; } 228 }; 229 230 /// One of the @link comparison_functors comparison functors@endlink. 231 template<typename _Tp> 232 struct less : public binary_function<_Tp, _Tp, bool> 233 { 234 bool 235 operator()(const _Tp& __x, const _Tp& __y) const 236 { return __x < __y; } 237 }; 238 239 /// One of the @link comparison_functors comparison functors@endlink. 240 template<typename _Tp> 241 struct greater_equal : public binary_function<_Tp, _Tp, bool> 242 { 243 bool 244 operator()(const _Tp& __x, const _Tp& __y) const 245 { return __x >= __y; } 246 }; 247 248 /// One of the @link comparison_functors comparison functors@endlink. 249 template<typename _Tp> 250 struct less_equal : public binary_function<_Tp, _Tp, bool> 251 { 252 bool 253 operator()(const _Tp& __x, const _Tp& __y) const 254 { return __x <= __y; } 255 }; 256 /** @} */ 257 258 // 20.3.4 logical operations 259 /** @defgroup logical_functors Boolean Operations Classes 260 * @ingroup functors 261 * 262 * Here are wrapper functors for Boolean operations: @c &&, @c ||, 263 * and @c !. 264 * 265 * @{ 266 */ 267 /// One of the @link logical_functors Boolean operations functors@endlink. 268 template<typename _Tp> 269 struct logical_and : public binary_function<_Tp, _Tp, bool> 270 { 271 bool 272 operator()(const _Tp& __x, const _Tp& __y) const 273 { return __x && __y; } 274 }; 275 276 /// One of the @link logical_functors Boolean operations functors@endlink. 277 template<typename _Tp> 278 struct logical_or : public binary_function<_Tp, _Tp, bool> 279 { 280 bool 281 operator()(const _Tp& __x, const _Tp& __y) const 282 { return __x || __y; } 283 }; 284 285 /// One of the @link logical_functors Boolean operations functors@endlink. 286 template<typename _Tp> 287 struct logical_not : public unary_function<_Tp, bool> 288 { 289 bool 290 operator()(const _Tp& __x) const 291 { return !__x; } 292 }; 293 /** @} */ 294 295 // _GLIBCXX_RESOLVE_LIB_DEFECTS 296 // DR 660. Missing Bitwise Operations. 297 template<typename _Tp> 298 struct bit_and : public binary_function<_Tp, _Tp, _Tp> 299 { 300 _Tp 301 operator()(const _Tp& __x, const _Tp& __y) const 302 { return __x & __y; } 303 }; 304 305 template<typename _Tp> 306 struct bit_or : public binary_function<_Tp, _Tp, _Tp> 307 { 308 _Tp 309 operator()(const _Tp& __x, const _Tp& __y) const 310 { return __x | __y; } 311 }; 312 313 template<typename _Tp> 314 struct bit_xor : public binary_function<_Tp, _Tp, _Tp> 315 { 316 _Tp 317 operator()(const _Tp& __x, const _Tp& __y) const 318 { return __x ^ __y; } 319 }; 320 321 // 20.3.5 negators 322 /** @defgroup negators Negators 323 * @ingroup functors 324 * 325 * The functions @c not1 and @c not2 each take a predicate functor 326 * and return an instance of @c unary_negate or 327 * @c binary_negate, respectively. These classes are functors whose 328 * @c operator() performs the stored predicate function and then returns 329 * the negation of the result. 330 * 331 * For example, given a vector of integers and a trivial predicate, 332 * \code 333 * struct IntGreaterThanThree 334 * : public std::unary_function<int, bool> 335 * { 336 * bool operator() (int x) { return x > 3; } 337 * }; 338 * 339 * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree())); 340 * \endcode 341 * The call to @c find_if will locate the first index (i) of @c v for which 342 * <code>!(v[i] > 3)</code> is true. 343 * 344 * The not1/unary_negate combination works on predicates taking a single 345 * argument. The not2/binary_negate combination works on predicates which 346 * take two arguments. 347 * 348 * @{ 349 */ 350 /// One of the @link negators negation functors@endlink. 351 template<typename _Predicate> 352 class unary_negate 353 : public unary_function<typename _Predicate::argument_type, bool> 354 { 355 protected: 356 _Predicate _M_pred; 357 358 public: 359 explicit 360 unary_negate(const _Predicate& __x) : _M_pred(__x) { } 361 362 bool 363 operator()(const typename _Predicate::argument_type& __x) const 364 { return !_M_pred(__x); } 365 }; 366 367 /// One of the @link negators negation functors@endlink. 368 template<typename _Predicate> 369 inline unary_negate<_Predicate> 370 not1(const _Predicate& __pred) 371 { return unary_negate<_Predicate>(__pred); } 372 373 /// One of the @link negators negation functors@endlink. 374 template<typename _Predicate> 375 class binary_negate 376 : public binary_function<typename _Predicate::first_argument_type, 377 typename _Predicate::second_argument_type, bool> 378 { 379 protected: 380 _Predicate _M_pred; 381 382 public: 383 explicit 384 binary_negate(const _Predicate& __x) : _M_pred(__x) { } 385 386 bool 387 operator()(const typename _Predicate::first_argument_type& __x, 388 const typename _Predicate::second_argument_type& __y) const 389 { return !_M_pred(__x, __y); } 390 }; 391 392 /// One of the @link negators negation functors@endlink. 393 template<typename _Predicate> 394 inline binary_negate<_Predicate> 395 not2(const _Predicate& __pred) 396 { return binary_negate<_Predicate>(__pred); } 397 /** @} */ 398 399 // 20.3.7 adaptors pointers functions 400 /** @defgroup pointer_adaptors Adaptors for pointers to functions 401 * @ingroup functors 402 * 403 * The advantage of function objects over pointers to functions is that 404 * the objects in the standard library declare nested typedefs describing 405 * their argument and result types with uniform names (e.g., @c result_type 406 * from the base classes @c unary_function and @c binary_function). 407 * Sometimes those typedefs are required, not just optional. 408 * 409 * Adaptors are provided to turn pointers to unary (single-argument) and 410 * binary (double-argument) functions into function objects. The 411 * long-winded functor @c pointer_to_unary_function is constructed with a 412 * function pointer @c f, and its @c operator() called with argument @c x 413 * returns @c f(x). The functor @c pointer_to_binary_function does the same 414 * thing, but with a double-argument @c f and @c operator(). 415 * 416 * The function @c ptr_fun takes a pointer-to-function @c f and constructs 417 * an instance of the appropriate functor. 418 * 419 * @{ 420 */ 421 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 422 template<typename _Arg, typename _Result> 423 class pointer_to_unary_function : public unary_function<_Arg, _Result> 424 { 425 protected: 426 _Result (*_M_ptr)(_Arg); 427 428 public: 429 pointer_to_unary_function() { } 430 431 explicit 432 pointer_to_unary_function(_Result (*__x)(_Arg)) 433 : _M_ptr(__x) { } 434 435 _Result 436 operator()(_Arg __x) const 437 { return _M_ptr(__x); } 438 }; 439 440 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 441 template<typename _Arg, typename _Result> 442 inline pointer_to_unary_function<_Arg, _Result> 443 ptr_fun(_Result (*__x)(_Arg)) 444 { return pointer_to_unary_function<_Arg, _Result>(__x); } 445 446 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 447 template<typename _Arg1, typename _Arg2, typename _Result> 448 class pointer_to_binary_function 449 : public binary_function<_Arg1, _Arg2, _Result> 450 { 451 protected: 452 _Result (*_M_ptr)(_Arg1, _Arg2); 453 454 public: 455 pointer_to_binary_function() { } 456 457 explicit 458 pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) 459 : _M_ptr(__x) { } 460 461 _Result 462 operator()(_Arg1 __x, _Arg2 __y) const 463 { return _M_ptr(__x, __y); } 464 }; 465 466 /// One of the @link pointer_adaptors adaptors for function pointers@endlink. 467 template<typename _Arg1, typename _Arg2, typename _Result> 468 inline pointer_to_binary_function<_Arg1, _Arg2, _Result> 469 ptr_fun(_Result (*__x)(_Arg1, _Arg2)) 470 { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } 471 /** @} */ 472 473 template<typename _Tp> 474 struct _Identity : 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 : public unary_function<_Pair, 487 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#ifdef __GXX_EXPERIMENTAL_CXX0X__ 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 : public unary_function<_Pair, 512 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 !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_USE_DEPRECATED 731# include <backward/binders.h> 732#endif 733 734#endif /* _STL_FUNCTION_H */ 735