contrib/gcc-4.4/libstdc++-v3/include/bits/stl_function.h

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