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