libstdc++-v3/include/bits/stl_function.h

   1 // Functor implementations -*- C++ -*-
   2
   3 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009, 2010
   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
  60 namespace 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_DEPRECATED
 731 # include <backward/binders.h>
 732 #endif
 733
 734 #endif /* _STL_FUNCTION_H */