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, 2011
4 // Free Software Foundation, Inc.
5 //
6 // This file is part of the GNU ISO C++ Library. This library is free
7 // software; you can redistribute it and/or modify it under the
8 // terms of the GNU General Public License as published by the
9 // Free Software Foundation; either version 3, or (at your option)
10 // any later version.
11 
12 // This library is distributed in the hope that it will be useful,
13 // but WITHOUT ANY WARRANTY; without even the implied warranty of
14 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 // GNU General Public License for more details.
16 
17 // Under Section 7 of GPL version 3, you are granted additional
18 // permissions described in the GCC Runtime Library Exception, version
19 // 3.1, as published by the Free Software Foundation.
20 
21 // You should have received a copy of the GNU General Public License and
22 // a copy of the GCC Runtime Library Exception along with this program;
23 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
24 // <http://www.gnu.org/licenses/>.
25 
26 /*
27  *
28  * Copyright (c) 1994
29  * Hewlett-Packard Company
30  *
31  * Permission to use, copy, modify, distribute and sell this software
32  * and its documentation for any purpose is hereby granted without fee,
33  * provided that the above copyright notice appear in all copies and
34  * that both that copyright notice and this permission notice appear
35  * in supporting documentation. Hewlett-Packard Company makes no
36  * representations about the suitability of this software for any
37  * purpose. It is provided "as is" without express or implied warranty.
38  *
39  *
40  * Copyright (c) 1996-1998
41  * Silicon Graphics Computer Systems, Inc.
42  *
43  * Permission to use, copy, modify, distribute and sell this software
44  * and its documentation for any purpose is hereby granted without fee,
45  * provided that the above copyright notice appear in all copies and
46  * that both that copyright notice and this permission notice appear
47  * in supporting documentation. Silicon Graphics makes no
48  * representations about the suitability of this software for any
49  * purpose. It is provided "as is" without express or implied warranty.
50  */
51 
52 /** @file bits/stl_function.h
53  * This is an internal header file, included by other library headers.
54  * Do not attempt to use it directly. @headername{functional}
55  */
56 
57 #ifndef _STL_FUNCTION_H
58 #define _STL_FUNCTION_H 1
59 
60 namespace std _GLIBCXX_VISIBILITY(default)
61 {
62 _GLIBCXX_BEGIN_NAMESPACE_VERSION
63 
64  // 20.3.1 base classes
65  /** @defgroup functors Function Objects
66  * @ingroup utilities
67  *
68  * Function objects, or @e functors, are objects with an @c operator()
69  * defined and accessible. They can be passed as arguments to algorithm
70  * templates and used in place of a function pointer. Not only is the
71  * resulting expressiveness of the library increased, but the generated
72  * code can be more efficient than what you might write by hand. When we
73  * refer to @a functors, then, generally we include function pointers in
74  * the description as well.
75  *
76  * Often, functors are only created as temporaries passed to algorithm
77  * calls, rather than being created as named variables.
78  *
79  * Two examples taken from the standard itself follow. To perform a
80  * by-element addition of two vectors @c a and @c b containing @c double,
81  * and put the result in @c a, use
82  * \code
83  * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
84  * \endcode
85  * To negate every element in @c a, use
86  * \code
87  * transform(a.begin(), a.end(), a.begin(), negate<double>());
88  * \endcode
89  * The addition and negation functions will be inlined directly.
90  *
91  * The standard functors are derived from structs named @c unary_function
92  * and @c binary_function. These two classes contain nothing but typedefs,
93  * to aid in generic (template) programming. If you write your own
94  * functors, you might consider doing the same.
95  *
96  * @{
97  */
98  /**
99  * This is one of the @link functors functor base classes@endlink.
100  */
101  template<typename _Arg, typename _Result>
103  {
104  /// @c argument_type is the type of the argument
105  typedef _Arg argument_type;
106 
107  /// @c result_type is the return type
108  typedef _Result result_type;
109  };
110 
111  /**
112  * This is one of the @link functors functor base classes@endlink.
113  */
114  template<typename _Arg1, typename _Arg2, typename _Result>
116  {
117  /// @c first_argument_type is the type of the first argument
118  typedef _Arg1 first_argument_type;
119 
120  /// @c second_argument_type is the type of the second argument
121  typedef _Arg2 second_argument_type;
122 
123  /// @c result_type is the return type
124  typedef _Result result_type;
125  };
126  /** @} */
127 
128  // 20.3.2 arithmetic
129  /** @defgroup arithmetic_functors Arithmetic Classes
130  * @ingroup functors
131  *
132  * Because basic math often needs to be done during an algorithm,
133  * the library provides functors for those operations. See the
134  * documentation for @link functors the base classes@endlink
135  * for examples of their use.
136  *
137  * @{
138  */
139  /// One of the @link arithmetic_functors math functors@endlink.
140  template<typename _Tp>
141  struct plus : public binary_function<_Tp, _Tp, _Tp>
142  {
143  _Tp
144  operator()(const _Tp& __x, const _Tp& __y) const
145  { return __x + __y; }
146  };
147 
148  /// One of the @link arithmetic_functors math functors@endlink.
149  template<typename _Tp>
150  struct minus : public binary_function<_Tp, _Tp, _Tp>
151  {
152  _Tp
153  operator()(const _Tp& __x, const _Tp& __y) const
154  { return __x - __y; }
155  };
156 
157  /// One of the @link arithmetic_functors math functors@endlink.
158  template<typename _Tp>
159  struct multiplies : public binary_function<_Tp, _Tp, _Tp>
160  {
161  _Tp
162  operator()(const _Tp& __x, const _Tp& __y) const
163  { return __x * __y; }
164  };
165 
166  /// One of the @link arithmetic_functors math functors@endlink.
167  template<typename _Tp>
168  struct divides : public binary_function<_Tp, _Tp, _Tp>
169  {
170  _Tp
171  operator()(const _Tp& __x, const _Tp& __y) const
172  { return __x / __y; }
173  };
174 
175  /// One of the @link arithmetic_functors math functors@endlink.
176  template<typename _Tp>
177  struct modulus : public binary_function<_Tp, _Tp, _Tp>
178  {
179  _Tp
180  operator()(const _Tp& __x, const _Tp& __y) const
181  { return __x % __y; }
182  };
183 
184  /// One of the @link arithmetic_functors math functors@endlink.
185  template<typename _Tp>
186  struct negate : public unary_function<_Tp, _Tp>
187  {
188  _Tp
189  operator()(const _Tp& __x) const
190  { return -__x; }
191  };
192  /** @} */
193 
194  // 20.3.3 comparisons
195  /** @defgroup comparison_functors Comparison Classes
196  * @ingroup functors
197  *
198  * The library provides six wrapper functors for all the basic comparisons
199  * in C++, like @c <.
200  *
201  * @{
202  */
203  /// One of the @link comparison_functors comparison functors@endlink.
204  template<typename _Tp>
205  struct equal_to : public binary_function<_Tp, _Tp, bool>
206  {
207  bool
208  operator()(const _Tp& __x, const _Tp& __y) const
209  { return __x == __y; }
210  };
211 
212  /// One of the @link comparison_functors comparison functors@endlink.
213  template<typename _Tp>
214  struct not_equal_to : public binary_function<_Tp, _Tp, bool>
215  {
216  bool
217  operator()(const _Tp& __x, const _Tp& __y) const
218  { return __x != __y; }
219  };
220 
221  /// One of the @link comparison_functors comparison functors@endlink.
222  template<typename _Tp>
223  struct greater : public binary_function<_Tp, _Tp, bool>
224  {
225  bool
226  operator()(const _Tp& __x, const _Tp& __y) const
227  { return __x > __y; }
228  };
229 
230  /// One of the @link comparison_functors comparison functors@endlink.
231  template<typename _Tp>
232  struct less : public binary_function<_Tp, _Tp, bool>
233  {
234  bool
235  operator()(const _Tp& __x, const _Tp& __y) const
236  { return __x < __y; }
237  };
238 
239  /// One of the @link comparison_functors comparison functors@endlink.
240  template<typename _Tp>
241  struct greater_equal : public binary_function<_Tp, _Tp, bool>
242  {
243  bool
244  operator()(const _Tp& __x, const _Tp& __y) const
245  { return __x >= __y; }
246  };
247 
248  /// One of the @link comparison_functors comparison functors@endlink.
249  template<typename _Tp>
250  struct less_equal : public binary_function<_Tp, _Tp, bool>
251  {
252  bool
253  operator()(const _Tp& __x, const _Tp& __y) const
254  { return __x <= __y; }
255  };
256  /** @} */
257 
258  // 20.3.4 logical operations
259  /** @defgroup logical_functors Boolean Operations Classes
260  * @ingroup functors
261  *
262  * Here are wrapper functors for Boolean operations: @c &&, @c ||,
263  * and @c !.
264  *
265  * @{
266  */
267  /// One of the @link logical_functors Boolean operations functors@endlink.
268  template<typename _Tp>
269  struct logical_and : public binary_function<_Tp, _Tp, bool>
270  {
271  bool
272  operator()(const _Tp& __x, const _Tp& __y) const
273  { return __x && __y; }
274  };
275 
276  /// One of the @link logical_functors Boolean operations functors@endlink.
277  template<typename _Tp>
278  struct logical_or : public binary_function<_Tp, _Tp, bool>
279  {
280  bool
281  operator()(const _Tp& __x, const _Tp& __y) const
282  { return __x || __y; }
283  };
284 
285  /// One of the @link logical_functors Boolean operations functors@endlink.
286  template<typename _Tp>
287  struct logical_not : public unary_function<_Tp, bool>
288  {
289  bool
290  operator()(const _Tp& __x) const
291  { return !__x; }
292  };
293  /** @} */
294 
295  // _GLIBCXX_RESOLVE_LIB_DEFECTS
296  // DR 660. Missing Bitwise Operations.
297  template<typename _Tp>
298  struct bit_and : public binary_function<_Tp, _Tp, _Tp>
299  {
300  _Tp
301  operator()(const _Tp& __x, const _Tp& __y) const
302  { return __x & __y; }
303  };
304 
305  template<typename _Tp>
306  struct bit_or : public binary_function<_Tp, _Tp, _Tp>
307  {
308  _Tp
309  operator()(const _Tp& __x, const _Tp& __y) const
310  { return __x | __y; }
311  };
312 
313  template<typename _Tp>
314  struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
315  {
316  _Tp
317  operator()(const _Tp& __x, const _Tp& __y) const
318  { return __x ^ __y; }
319  };
320 
321  // 20.3.5 negators
322  /** @defgroup negators Negators
323  * @ingroup functors
324  *
325  * The functions @c not1 and @c not2 each take a predicate functor
326  * and return an instance of @c unary_negate or
327  * @c binary_negate, respectively. These classes are functors whose
328  * @c operator() performs the stored predicate function and then returns
329  * the negation of the result.
330  *
331  * For example, given a vector of integers and a trivial predicate,
332  * \code
333  * struct IntGreaterThanThree
334  * : public std::unary_function<int, bool>
335  * {
336  * bool operator() (int x) { return x > 3; }
337  * };
338  *
339  * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
340  * \endcode
341  * The call to @c find_if will locate the first index (i) of @c v for which
342  * <code>!(v[i] > 3)</code> is true.
343  *
344  * The not1/unary_negate combination works on predicates taking a single
345  * argument. The not2/binary_negate combination works on predicates which
346  * take two arguments.
347  *
348  * @{
349  */
350  /// One of the @link negators negation functors@endlink.
351  template<typename _Predicate>
353  : public unary_function<typename _Predicate::argument_type, bool>
354  {
355  protected:
356  _Predicate _M_pred;
357 
358  public:
359  explicit
360  unary_negate(const _Predicate& __x) : _M_pred(__x) { }
361 
362  bool
363  operator()(const typename _Predicate::argument_type& __x) const
364  { return !_M_pred(__x); }
365  };
366 
367  /// One of the @link negators negation functors@endlink.
368  template<typename _Predicate>
370  not1(const _Predicate& __pred)
371  { return unary_negate<_Predicate>(__pred); }
372 
373  /// One of the @link negators negation functors@endlink.
374  template<typename _Predicate>
376  : public binary_function<typename _Predicate::first_argument_type,
377  typename _Predicate::second_argument_type, bool>
378  {
379  protected:
380  _Predicate _M_pred;
381 
382  public:
383  explicit
384  binary_negate(const _Predicate& __x) : _M_pred(__x) { }
385 
386  bool
387  operator()(const typename _Predicate::first_argument_type& __x,
388  const typename _Predicate::second_argument_type& __y) const
389  { return !_M_pred(__x, __y); }
390  };
391 
392  /// One of the @link negators negation functors@endlink.
393  template<typename _Predicate>
395  not2(const _Predicate& __pred)
396  { return binary_negate<_Predicate>(__pred); }
397  /** @} */
398 
399  // 20.3.7 adaptors pointers functions
400  /** @defgroup pointer_adaptors Adaptors for pointers to functions
401  * @ingroup functors
402  *
403  * The advantage of function objects over pointers to functions is that
404  * the objects in the standard library declare nested typedefs describing
405  * their argument and result types with uniform names (e.g., @c result_type
406  * from the base classes @c unary_function and @c binary_function).
407  * Sometimes those typedefs are required, not just optional.
408  *
409  * Adaptors are provided to turn pointers to unary (single-argument) and
410  * binary (double-argument) functions into function objects. The
411  * long-winded functor @c pointer_to_unary_function is constructed with a
412  * function pointer @c f, and its @c operator() called with argument @c x
413  * returns @c f(x). The functor @c pointer_to_binary_function does the same
414  * thing, but with a double-argument @c f and @c operator().
415  *
416  * The function @c ptr_fun takes a pointer-to-function @c f and constructs
417  * an instance of the appropriate functor.
418  *
419  * @{
420  */
421  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
422  template<typename _Arg, typename _Result>
423  class pointer_to_unary_function : public unary_function<_Arg, _Result>
424  {
425  protected:
426  _Result (*_M_ptr)(_Arg);
427 
428  public:
430 
431  explicit
432  pointer_to_unary_function(_Result (*__x)(_Arg))
433  : _M_ptr(__x) { }
434 
435  _Result
436  operator()(_Arg __x) const
437  { return _M_ptr(__x); }
438  };
439 
440  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
441  template<typename _Arg, typename _Result>
443  ptr_fun(_Result (*__x)(_Arg))
445 
446  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
447  template<typename _Arg1, typename _Arg2, typename _Result>
449  : public binary_function<_Arg1, _Arg2, _Result>
450  {
451  protected:
452  _Result (*_M_ptr)(_Arg1, _Arg2);
453 
454  public:
456 
457  explicit
458  pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
459  : _M_ptr(__x) { }
460 
461  _Result
462  operator()(_Arg1 __x, _Arg2 __y) const
463  { return _M_ptr(__x, __y); }
464  };
465 
466  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
467  template<typename _Arg1, typename _Arg2, typename _Result>
469  ptr_fun(_Result (*__x)(_Arg1, _Arg2))
471  /** @} */
472 
473  template<typename _Tp>
474  struct _Identity : 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  { return __x; }
483  };
484 
485  template<typename _Pair>
486  struct _Select1st : public unary_function<_Pair,
487  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  { return __x.first; }
496 
497 #ifdef __GXX_EXPERIMENTAL_CXX0X__
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 : public unary_function<_Pair,
512  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 !defined(__GXX_EXPERIMENTAL_CXX0X__) || _GLIBCXX_USE_DEPRECATED
731 # include <backward/binders.h>
732 #endif
733 
734 #endif /* _STL_FUNCTION_H */
One of the adaptors for member pointers.
Definition: stl_function.h:542
_Result result_type
result_type is the return type
Definition: stl_function.h:108
One of the adaptors for function pointers.
Definition: stl_function.h:448
One of the negation functors.
Definition: stl_function.h:375
pointer_to_unary_function< _Arg, _Result > ptr_fun(_Result(*__x)(_Arg))
One of the adaptors for function pointers.
Definition: stl_function.h:443
One of the adaptors for member pointers.
Definition: stl_function.h:632
One of the math functors.
Definition: stl_function.h:186
One of the math functors.
Definition: stl_function.h:168
One of the Boolean operations functors.
Definition: stl_function.h:287
One of the math functors.
Definition: stl_function.h:141
One of the comparison functors.
Definition: stl_function.h:205
One of the adaptors for member pointers.
Definition: stl_function.h:578
One of the comparison functors.
Definition: stl_function.h:250
One of the math functors.
Definition: stl_function.h:177
One of the comparison functors.
Definition: stl_function.h:241
One of the Boolean operations functors.
Definition: stl_function.h:269
One of the adaptors for member pointers.
Definition: stl_function.h:668
One of the adaptors for member pointers.
Definition: stl_function.h:614
_Arg2 second_argument_type
second_argument_type is the type of the second argument
Definition: stl_function.h:121
One of the math functors.
Definition: stl_function.h:159
One of the adaptors for member pointers.
Definition: stl_function.h:560
unary_negate< _Predicate > not1(const _Predicate &__pred)
One of the negation functors.
Definition: stl_function.h:370
One of the negation functors.
Definition: stl_function.h:352
_Result result_type
result_type is the return type
Definition: stl_function.h:124
One of the math functors.
Definition: stl_function.h:150
One of the adaptors for function pointers.
Definition: stl_function.h:423
One of the comparison functors.
Definition: stl_function.h:232
_Arg1 first_argument_type
first_argument_type is the type of the first argument
Definition: stl_function.h:118
One of the comparison functors.
Definition: stl_function.h:223
One of the comparison functors.
Definition: stl_function.h:214
_Arg argument_type
argument_type is the type of the argument
Definition: stl_function.h:105
binary_negate< _Predicate > not2(const _Predicate &__pred)
One of the negation functors.
Definition: stl_function.h:395
One of the adaptors for member pointers.
Definition: stl_function.h:650
One of the Boolean operations functors.
Definition: stl_function.h:278
One of the adaptors for member pointers.
Definition: stl_function.h:596