libstdc++
stl_function.h
Go to the documentation of this file.
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>
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>
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>
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>
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>
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>
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:
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>
444  ptr_fun(_Result (*__x)(_Arg))
446 
447  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
448  template<typename _Arg1, typename _Arg2, typename _Result>
450  : public binary_function<_Arg1, _Arg2, _Result>
451  {
452  protected:
453  _Result (*_M_ptr)(_Arg1, _Arg2);
454 
455  public:
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>
470  ptr_fun(_Result (*__x)(_Arg1, _Arg2))
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 */