# stl_function.h

Go to the documentation of this file.

    00001 // Functor implementations -*- C++ -*-
    00002
    00003 // Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2009
    00004 // Free Software Foundation, Inc.
    00005 //
    00006 // This file is part of the GNU ISO C++ Library.  This library is free
    00007 // software; you can redistribute it and/or modify it under the
    00008 // terms of the GNU General Public License as published by the
    00009 // Free Software Foundation; either version 3, or (at your option)
    00010 // any later version.
    00011
    00012 // This library is distributed in the hope that it will be useful,
    00013 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00014 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00015 // GNU General Public License for more details.
    00016
    00017 // Under Section 7 of GPL version 3, you are granted additional
    00018 // permissions described in the GCC Runtime Library Exception, version
    00019 // 3.1, as published by the Free Software Foundation.
    00020
    00021 // You should have received a copy of the GNU General Public License and
    00022 // a copy of the GCC Runtime Library Exception along with this program;
    00023 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
    00024 // <http://www.gnu.org/licenses/>.
    00025
    00026 /*
    00027  *
    00028  * Copyright (c) 1994
    00029  * Hewlett-Packard Company
    00030  *
    00031  * Permission to use, copy, modify, distribute and sell this software
    00032  * and its documentation for any purpose is hereby granted without fee,
    00033  * provided that the above copyright notice appear in all copies and
    00034  * that both that copyright notice and this permission notice appear
    00035  * in supporting documentation.  Hewlett-Packard Company makes no
    00036  * representations about the suitability of this software for any
    00037  * purpose.  It is provided "as is" without express or implied warranty.
    00038  *
    00039  *
    00040  * Copyright (c) 1996-1998
    00041  * Silicon Graphics Computer Systems, Inc.
    00042  *
    00043  * Permission to use, copy, modify, distribute and sell this software
    00044  * and its documentation for any purpose is hereby granted without fee,
    00045  * provided that the above copyright notice appear in all copies and
    00046  * that both that copyright notice and this permission notice appear
    00047  * in supporting documentation.  Silicon Graphics makes no
    00048  * representations about the suitability of this software for any
    00049  * purpose.  It is provided "as is" without express or implied warranty.
    00050  */
    00051
    00052 /** @file stl_function.h
    00053  *  This is an internal header file, included by other library headers.
    00054  *  You should not attempt to use it directly.
    00055  */
    00056
    00057 #ifndef _STL_FUNCTION_H
    00058 #define _STL_FUNCTION_H 1
    00059
    00060 _GLIBCXX_BEGIN_NAMESPACE(std)
    00061
    00062   // 20.3.1 base classes
    00063   /** @defgroup functors Function Objects
    00064    * @ingroup utilities
    00065    *
    00066    *  Function objects, or @e functors, are objects with an @c operator()
    00067    *  defined and accessible.  They can be passed as arguments to algorithm
    00068    *  templates and used in place of a function pointer.  Not only is the
    00069    *  resulting expressiveness of the library increased, but the generated
    00070    *  code can be more efficient than what you might write by hand.  When we
    00071    *  refer to "functors," then, generally we include function pointers in
    00072    *  the description as well.
    00073    *
    00074    *  Often, functors are only created as temporaries passed to algorithm
    00075    *  calls, rather than being created as named variables.
    00076    *
    00077    *  Two examples taken from the standard itself follow.  To perform a
    00078    *  by-element addition of two vectors @c a and @c b containing @c double,
    00079    *  and put the result in @c a, use
    00080    *  \code
    00081    *  transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
    00082    *  \endcode
    00083    *  To negate every element in @c a, use
    00084    *  \code
    00085    *  transform(a.begin(), a.end(), a.begin(), negate<double>());
    00086    *  \endcode
    00087    *  The addition and negation functions will be inlined directly.
    00088    *
    00089    *  The standard functors are derived from structs named @c unary_function
    00090    *  and @c binary_function.  These two classes contain nothing but typedefs,
    00091    *  to aid in generic (template) programming.  If you write your own
    00092    *  functors, you might consider doing the same.
    00093    *
    00094    *  @{
    00095    */
    00096   /**
    00097    *  This is one of the @link functors functor base classes@endlink.
    00098    */
    00099   template<typename _Arg, typename _Result>
    00100     struct unary_function
    00101     {
    00102       typedef _Arg argument_type;   ///< @c argument_type is the type of the
    00103                                     ///     argument (no surprises here)
    00104
    00105       typedef _Result result_type;  ///< @c result_type is the return type
    00106     };
    00107
    00108   /**
    00109    *  This is one of the @link functors functor base classes@endlink.
    00110    */
    00111   template<typename _Arg1, typename _Arg2, typename _Result>
    00112     struct binary_function
    00113     {
    00114       typedef _Arg1 first_argument_type;   ///< the type of the first argument
    00115                                            ///  (no surprises here)
    00116
    00117       typedef _Arg2 second_argument_type;  ///< the type of the second argument
    00118       typedef _Result result_type;         ///< type of the return type
    00119     };
    00120   /** @}  */
    00121
    00122   // 20.3.2 arithmetic
    00123   /** @defgroup arithmetic_functors Arithmetic Classes
    00124    * @ingroup functors
    00125    *
    00126    *  Because basic math often needs to be done during an algorithm,
    00127    *  the library provides functors for those operations.  See the
    00128    *  documentation for @link functors the base classes@endlink
    00129    *  for examples of their use.
    00130    *
    00131    *  @{
    00132    */
    00133   /// One of the @link arithmetic_functors math functors@endlink.
    00134   template<typename _Tp>
    00135     struct plus : public binary_function<_Tp, _Tp, _Tp>
    00136     {
    00137       _Tp
    00138       operator()(const _Tp& __x, const _Tp& __y) const
    00139       { return __x + __y; }
    00140     };
    00141
    00142   /// One of the @link arithmetic_functors math functors@endlink.
    00143   template<typename _Tp>
    00144     struct minus : public binary_function<_Tp, _Tp, _Tp>
    00145     {
    00146       _Tp
    00147       operator()(const _Tp& __x, const _Tp& __y) const
    00148       { return __x - __y; }
    00149     };
    00150
    00151   /// One of the @link arithmetic_functors math functors@endlink.
    00152   template<typename _Tp>
    00153     struct multiplies : public binary_function<_Tp, _Tp, _Tp>
    00154     {
    00155       _Tp
    00156       operator()(const _Tp& __x, const _Tp& __y) const
    00157       { return __x * __y; }
    00158     };
    00159
    00160   /// One of the @link arithmetic_functors math functors@endlink.
    00161   template<typename _Tp>
    00162     struct divides : public binary_function<_Tp, _Tp, _Tp>
    00163     {
    00164       _Tp
    00165       operator()(const _Tp& __x, const _Tp& __y) const
    00166       { return __x / __y; }
    00167     };
    00168
    00169   /// One of the @link arithmetic_functors math functors@endlink.
    00170   template<typename _Tp>
    00171     struct modulus : public binary_function<_Tp, _Tp, _Tp>
    00172     {
    00173       _Tp
    00174       operator()(const _Tp& __x, const _Tp& __y) const
    00175       { return __x % __y; }
    00176     };
    00177
    00178   /// One of the @link arithmetic_functors math functors@endlink.
    00179   template<typename _Tp>
    00180     struct negate : public unary_function<_Tp, _Tp>
    00181     {
    00182       _Tp
    00183       operator()(const _Tp& __x) const
    00184       { return -__x; }
    00185     };
    00186   /** @}  */
    00187
    00188   // 20.3.3 comparisons
    00189   /** @defgroup comparison_functors Comparison Classes
    00190    * @ingroup functors
    00191    *
    00192    *  The library provides six wrapper functors for all the basic comparisons
    00193    *  in C++, like @c <.
    00194    *
    00195    *  @{
    00196    */
    00197   /// One of the @link comparison_functors comparison functors@endlink.
    00198   template<typename _Tp>
    00199     struct equal_to : public binary_function<_Tp, _Tp, bool>
    00200     {
    00201       bool
    00202       operator()(const _Tp& __x, const _Tp& __y) const
    00203       { return __x == __y; }
    00204     };
    00205
    00206   /// One of the @link comparison_functors comparison functors@endlink.
    00207   template<typename _Tp>
    00208     struct not_equal_to : public binary_function<_Tp, _Tp, bool>
    00209     {
    00210       bool
    00211       operator()(const _Tp& __x, const _Tp& __y) const
    00212       { return __x != __y; }
    00213     };
    00214
    00215   /// One of the @link comparison_functors comparison functors@endlink.
    00216   template<typename _Tp>
    00217     struct greater : public binary_function<_Tp, _Tp, bool>
    00218     {
    00219       bool
    00220       operator()(const _Tp& __x, const _Tp& __y) const
    00221       { return __x > __y; }
    00222     };
    00223
    00224   /// One of the @link comparison_functors comparison functors@endlink.
    00225   template<typename _Tp>
    00226     struct less : public binary_function<_Tp, _Tp, bool>
    00227     {
    00228       bool
    00229       operator()(const _Tp& __x, const _Tp& __y) const
    00230       { return __x < __y; }
    00231     };
    00232
    00233   /// One of the @link comparison_functors comparison functors@endlink.
    00234   template<typename _Tp>
    00235     struct greater_equal : public binary_function<_Tp, _Tp, bool>
    00236     {
    00237       bool
    00238       operator()(const _Tp& __x, const _Tp& __y) const
    00239       { return __x >= __y; }
    00240     };
    00241
    00242   /// One of the @link comparison_functors comparison functors@endlink.
    00243   template<typename _Tp>
    00244     struct less_equal : public binary_function<_Tp, _Tp, bool>
    00245     {
    00246       bool
    00247       operator()(const _Tp& __x, const _Tp& __y) const
    00248       { return __x <= __y; }
    00249     };
    00250   /** @}  */
    00251
    00252   // 20.3.4 logical operations
    00253   /** @defgroup logical_functors Boolean Operations Classes
    00254    * @ingroup functors
    00255    *
    00256    *  Here are wrapper functors for Boolean operations: @c &&, @c ||,
    00257    *  and @c !.
    00258    *
    00259    *  @{
    00260    */
    00261   /// One of the @link logical_functors Boolean operations functors@endlink.
    00262   template<typename _Tp>
    00263     struct logical_and : public binary_function<_Tp, _Tp, bool>
    00264     {
    00265       bool
    00266       operator()(const _Tp& __x, const _Tp& __y) const
    00267       { return __x && __y; }
    00268     };
    00269
    00270   /// One of the @link logical_functors Boolean operations functors@endlink.
    00271   template<typename _Tp>
    00272     struct logical_or : public binary_function<_Tp, _Tp, bool>
    00273     {
    00274       bool
    00275       operator()(const _Tp& __x, const _Tp& __y) const
    00276       { return __x || __y; }
    00277     };
    00278
    00279   /// One of the @link logical_functors Boolean operations functors@endlink.
    00280   template<typename _Tp>
    00281     struct logical_not : public unary_function<_Tp, bool>
    00282     {
    00283       bool
    00284       operator()(const _Tp& __x) const
    00285       { return !__x; }
    00286     };
    00287   /** @}  */
    00288
    00289   // _GLIBCXX_RESOLVE_LIB_DEFECTS
    00290   // DR 660. Missing Bitwise Operations.
    00291   template<typename _Tp>
    00292     struct bit_and : public binary_function<_Tp, _Tp, _Tp>
    00293     {
    00294       _Tp
    00295       operator()(const _Tp& __x, const _Tp& __y) const
    00296       { return __x & __y; }
    00297     };
    00298
    00299   template<typename _Tp>
    00300     struct bit_or : public binary_function<_Tp, _Tp, _Tp>
    00301     {
    00302       _Tp
    00303       operator()(const _Tp& __x, const _Tp& __y) const
    00304       { return __x | __y; }
    00305     };
    00306
    00307   template<typename _Tp>
    00308     struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
    00309     {
    00310       _Tp
    00311       operator()(const _Tp& __x, const _Tp& __y) const
    00312       { return __x ^ __y; }
    00313     };
    00314
    00315   // 20.3.5 negators
    00316   /** @defgroup negators Negators
    00317    * @ingroup functors
    00318    *
    00319    *  The functions @c not1 and @c not2 each take a predicate functor
    00320    *  and return an instance of @c unary_negate or
    00321    *  @c binary_negate, respectively.  These classes are functors whose
    00322    *  @c operator() performs the stored predicate function and then returns
    00323    *  the negation of the result.
    00324    *
    00325    *  For example, given a vector of integers and a trivial predicate,
    00326    *  \code
    00327    *  struct IntGreaterThanThree
    00328    *    : public std::unary_function<int, bool>
    00329    *  {
    00330    *      bool operator() (int x) { return x > 3; }
    00331    *  };
    00332    *
    00333    *  std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
    00334    *  \endcode
    00335    *  The call to @c find_if will locate the first index (i) of @c v for which
    00336    *  "!(v[i] > 3)" is true.
    00337    *
    00338    *  The not1/unary_negate combination works on predicates taking a single
    00339    *  argument.  The not2/binary_negate combination works on predicates which
    00340    *  take two arguments.
    00341    *
    00342    *  @{
    00343    */
    00344   /// One of the @link negators negation functors@endlink.
    00345   template<typename _Predicate>
    00346     class unary_negate
    00347     : public unary_function<typename _Predicate::argument_type, bool>
    00348     {
    00349     protected:
    00350       _Predicate _M_pred;
    00351
    00352     public:
    00353       explicit
    00354       unary_negate(const _Predicate& __x) : _M_pred(__x) { }
    00355
    00356       bool
    00357       operator()(const typename _Predicate::argument_type& __x) const
    00358       { return !_M_pred(__x); }
    00359     };
    00360
    00361   /// One of the @link negators negation functors@endlink.
    00362   template<typename _Predicate>
    00363     inline unary_negate<_Predicate>
    00364     not1(const _Predicate& __pred)
    00365     { return unary_negate<_Predicate>(__pred); }
    00366
    00367   /// One of the @link negators negation functors@endlink.
    00368   template<typename _Predicate>
    00369     class binary_negate
    00370     : public binary_function<typename _Predicate::first_argument_type,
    00371                  typename _Predicate::second_argument_type, bool>
    00372     {
    00373     protected:
    00374       _Predicate _M_pred;
    00375
    00376     public:
    00377       explicit
    00378       binary_negate(const _Predicate& __x) : _M_pred(__x) { }
    00379
    00380       bool
    00381       operator()(const typename _Predicate::first_argument_type& __x,
    00382          const typename _Predicate::second_argument_type& __y) const
    00383       { return !_M_pred(__x, __y); }
    00384     };
    00385
    00386   /// One of the @link negators negation functors@endlink.
    00387   template<typename _Predicate>
    00388     inline binary_negate<_Predicate>
    00389     not2(const _Predicate& __pred)
    00390     { return binary_negate<_Predicate>(__pred); }
    00391   /** @}  */
    00392
    00393   // 20.3.7 adaptors pointers functions
    00394   /** @defgroup pointer_adaptors Adaptors for pointers to functions
    00395    * @ingroup functors
    00396    *
    00397    *  The advantage of function objects over pointers to functions is that
    00398    *  the objects in the standard library declare nested typedefs describing
    00399    *  their argument and result types with uniform names (e.g., @c result_type
    00400    *  from the base classes @c unary_function and @c binary_function).
    00401    *  Sometimes those typedefs are required, not just optional.
    00402    *
    00403    *  Adaptors are provided to turn pointers to unary (single-argument) and
    00404    *  binary (double-argument) functions into function objects.  The
    00405    *  long-winded functor @c pointer_to_unary_function is constructed with a
    00406    *  function pointer @c f, and its @c operator() called with argument @c x
    00407    *  returns @c f(x).  The functor @c pointer_to_binary_function does the same
    00408    *  thing, but with a double-argument @c f and @c operator().
    00409    *
    00410    *  The function @c ptr_fun takes a pointer-to-function @c f and constructs
    00411    *  an instance of the appropriate functor.
    00412    *
    00413    *  @{
    00414    */
    00415   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
    00416   template<typename _Arg, typename _Result>
    00417     class pointer_to_unary_function : public unary_function<_Arg, _Result>
    00418     {
    00419     protected:
    00420       _Result (*_M_ptr)(_Arg);
    00421
    00422     public:
    00423       pointer_to_unary_function() { }
    00424
    00425       explicit
    00426       pointer_to_unary_function(_Result (*__x)(_Arg))
    00427       : _M_ptr(__x) { }
    00428
    00429       _Result
    00430       operator()(_Arg __x) const
    00431       { return _M_ptr(__x); }
    00432     };
    00433
    00434   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
    00435   template<typename _Arg, typename _Result>
    00436     inline pointer_to_unary_function<_Arg, _Result>
    00437     ptr_fun(_Result (*__x)(_Arg))
    00438     { return pointer_to_unary_function<_Arg, _Result>(__x); }
    00439
    00440   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
    00441   template<typename _Arg1, typename _Arg2, typename _Result>
    00442     class pointer_to_binary_function
    00443     : public binary_function<_Arg1, _Arg2, _Result>
    00444     {
    00445     protected:
    00446       _Result (*_M_ptr)(_Arg1, _Arg2);
    00447
    00448     public:
    00449       pointer_to_binary_function() { }
    00450
    00451       explicit
    00452       pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
    00453       : _M_ptr(__x) { }
    00454
    00455       _Result
    00456       operator()(_Arg1 __x, _Arg2 __y) const
    00457       { return _M_ptr(__x, __y); }
    00458     };
    00459
    00460   /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
    00461   template<typename _Arg1, typename _Arg2, typename _Result>
    00462     inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
    00463     ptr_fun(_Result (*__x)(_Arg1, _Arg2))
    00464     { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
    00465   /** @}  */
    00466
    00467   template<typename _Tp>
    00468     struct _Identity : public unary_function<_Tp,_Tp>
    00469     {
    00470       _Tp&
    00471       operator()(_Tp& __x) const
    00472       { return __x; }
    00473
    00474       const _Tp&
    00475       operator()(const _Tp& __x) const
    00476       { return __x; }
    00477     };
    00478
    00479   template<typename _Pair>
    00480     struct _Select1st : public unary_function<_Pair,
    00481                           typename _Pair::first_type>
    00482     {
    00483       typename _Pair::first_type&
    00484       operator()(_Pair& __x) const
    00485       { return __x.first; }
    00486
    00487       const typename _Pair::first_type&
    00488       operator()(const _Pair& __x) const
    00489       { return __x.first; }
    00490     };
    00491
    00492   template<typename _Pair>
    00493     struct _Select2nd : public unary_function<_Pair,
    00494                           typename _Pair::second_type>
    00495     {
    00496       typename _Pair::second_type&
    00497       operator()(_Pair& __x) const
    00498       { return __x.second; }
    00499
    00500       const typename _Pair::second_type&
    00501       operator()(const _Pair& __x) const
    00502       { return __x.second; }
    00503     };
    00504
    00505   // 20.3.8 adaptors pointers members
    00506   /** @defgroup memory_adaptors Adaptors for pointers to members
    00507    * @ingroup functors
    00508    *
    00509    *  There are a total of 8 = 2^3 function objects in this family.
    00510    *   (1) Member functions taking no arguments vs member functions taking
    00511    *        one argument.
    00512    *   (2) Call through pointer vs call through reference.
    00513    *   (3) Const vs non-const member function.
    00514    *
    00515    *  All of this complexity is in the function objects themselves.  You can
    00516    *   ignore it by using the helper function mem_fun and mem_fun_ref,
    00517    *   which create whichever type of adaptor is appropriate.
    00518    *
    00519    *  @{
    00520    */
    00521   /// One of the @link memory_adaptors adaptors for member
    00522   /// pointers@endlink.
    00523   template<typename _Ret, typename _Tp>
    00524     class mem_fun_t : public unary_function<_Tp*, _Ret>
    00525     {
    00526     public:
    00527       explicit
    00528       mem_fun_t(_Ret (_Tp::*__pf)())
    00529       : _M_f(__pf) { }
    00530
    00531       _Ret
    00532       operator()(_Tp* __p) const
    00533       { return (__p->*_M_f)(); }
    00534
    00535     private:
    00536       _Ret (_Tp::*_M_f)();
    00537     };
    00538
    00539   /// One of the @link memory_adaptors adaptors for member
    00540   /// pointers@endlink.
    00541   template<typename _Ret, typename _Tp>
    00542     class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
    00543     {
    00544     public:
    00545       explicit
    00546       const_mem_fun_t(_Ret (_Tp::*__pf)() const)
    00547       : _M_f(__pf) { }
    00548
    00549       _Ret
    00550       operator()(const _Tp* __p) const
    00551       { return (__p->*_M_f)(); }
    00552
    00553     private:
    00554       _Ret (_Tp::*_M_f)() const;
    00555     };
    00556
    00557   /// One of the @link memory_adaptors adaptors for member
    00558   /// pointers@endlink.
    00559   template<typename _Ret, typename _Tp>
    00560     class mem_fun_ref_t : public unary_function<_Tp, _Ret>
    00561     {
    00562     public:
    00563       explicit
    00564       mem_fun_ref_t(_Ret (_Tp::*__pf)())
    00565       : _M_f(__pf) { }
    00566
    00567       _Ret
    00568       operator()(_Tp& __r) const
    00569       { return (__r.*_M_f)(); }
    00570
    00571     private:
    00572       _Ret (_Tp::*_M_f)();
    00573   };
    00574
    00575   /// One of the @link memory_adaptors adaptors for member
    00576   /// pointers@endlink.
    00577   template<typename _Ret, typename _Tp>
    00578     class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
    00579     {
    00580     public:
    00581       explicit
    00582       const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
    00583       : _M_f(__pf) { }
    00584
    00585       _Ret
    00586       operator()(const _Tp& __r) const
    00587       { return (__r.*_M_f)(); }
    00588
    00589     private:
    00590       _Ret (_Tp::*_M_f)() const;
    00591     };
    00592
    00593   /// One of the @link memory_adaptors adaptors for member
    00594   /// pointers@endlink.
    00595   template<typename _Ret, typename _Tp, typename _Arg>
    00596     class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
    00597     {
    00598     public:
    00599       explicit
    00600       mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
    00601       : _M_f(__pf) { }
    00602
    00603       _Ret
    00604       operator()(_Tp* __p, _Arg __x) const
    00605       { return (__p->*_M_f)(__x); }
    00606
    00607     private:
    00608       _Ret (_Tp::*_M_f)(_Arg);
    00609     };
    00610
    00611   /// One of the @link memory_adaptors adaptors for member
    00612   /// pointers@endlink.
    00613   template<typename _Ret, typename _Tp, typename _Arg>
    00614     class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
    00615     {
    00616     public:
    00617       explicit
    00618       const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
    00619       : _M_f(__pf) { }
    00620
    00621       _Ret
    00622       operator()(const _Tp* __p, _Arg __x) const
    00623       { return (__p->*_M_f)(__x); }
    00624
    00625     private:
    00626       _Ret (_Tp::*_M_f)(_Arg) const;
    00627     };
    00628
    00629   /// One of the @link memory_adaptors adaptors for member
    00630   /// pointers@endlink.
    00631   template<typename _Ret, typename _Tp, typename _Arg>
    00632     class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    00633     {
    00634     public:
    00635       explicit
    00636       mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
    00637       : _M_f(__pf) { }
    00638
    00639       _Ret
    00640       operator()(_Tp& __r, _Arg __x) const
    00641       { return (__r.*_M_f)(__x); }
    00642
    00643     private:
    00644       _Ret (_Tp::*_M_f)(_Arg);
    00645     };
    00646
    00647   /// One of the @link memory_adaptors adaptors for member
    00648   /// pointers@endlink.
    00649   template<typename _Ret, typename _Tp, typename _Arg>
    00650     class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
    00651     {
    00652     public:
    00653       explicit
    00654       const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
    00655       : _M_f(__pf) { }
    00656
    00657       _Ret
    00658       operator()(const _Tp& __r, _Arg __x) const
    00659       { return (__r.*_M_f)(__x); }
    00660
    00661     private:
    00662       _Ret (_Tp::*_M_f)(_Arg) const;
    00663     };
    00664
    00665   // Mem_fun adaptor helper functions.  There are only two:
    00666   // mem_fun and mem_fun_ref.
    00667   template<typename _Ret, typename _Tp>
    00668     inline mem_fun_t<_Ret, _Tp>
    00669     mem_fun(_Ret (_Tp::*__f)())
    00670     { return mem_fun_t<_Ret, _Tp>(__f); }
    00671
    00672   template<typename _Ret, typename _Tp>
    00673     inline const_mem_fun_t<_Ret, _Tp>
    00674     mem_fun(_Ret (_Tp::*__f)() const)
    00675     { return const_mem_fun_t<_Ret, _Tp>(__f); }
    00676
    00677   template<typename _Ret, typename _Tp>
    00678     inline mem_fun_ref_t<_Ret, _Tp>
    00679     mem_fun_ref(_Ret (_Tp::*__f)())
    00680     { return mem_fun_ref_t<_Ret, _Tp>(__f); }
    00681
    00682   template<typename _Ret, typename _Tp>
    00683     inline const_mem_fun_ref_t<_Ret, _Tp>
    00684     mem_fun_ref(_Ret (_Tp::*__f)() const)
    00685     { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
    00686
    00687   template<typename _Ret, typename _Tp, typename _Arg>
    00688     inline mem_fun1_t<_Ret, _Tp, _Arg>
    00689     mem_fun(_Ret (_Tp::*__f)(_Arg))
    00690     { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
    00691
    00692   template<typename _Ret, typename _Tp, typename _Arg>
    00693     inline const_mem_fun1_t<_Ret, _Tp, _Arg>
    00694     mem_fun(_Ret (_Tp::*__f)(_Arg) const)
    00695     { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
    00696
    00697   template<typename _Ret, typename _Tp, typename _Arg>
    00698     inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
    00699     mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
    00700     { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
    00701
    00702   template<typename _Ret, typename _Tp, typename _Arg>
    00703     inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
    00704     mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
    00705     { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
    00706
    00707   /** @}  */
    00708
    00709 _GLIBCXX_END_NAMESPACE
    00710
    00711 #if !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_DEPRECATED
    00712 # include <backward/binders.h>
    00713 #endif
    00714
    00715 #endif /* _STL_FUNCTION_H */