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
61namespace 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 */
745