i686-linux-gnu-4.7/usr/include/c++/4.7/bits/stl_function.h

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