libstdc++
stl_function.h
Go to the documentation of this file.
1 // Functor implementations -*- C++ -*-
2 
3 // Copyright (C) 2001-2018 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 #if __cplusplus > 201103L
60 #include <bits/move.h>
61 #endif
62 
63 namespace std _GLIBCXX_VISIBILITY(default)
64 {
65 _GLIBCXX_BEGIN_NAMESPACE_VERSION
66 
67  // 20.3.1 base classes
68  /** @defgroup functors Function Objects
69  * @ingroup utilities
70  *
71  * Function objects, or @e functors, are objects with an @c operator()
72  * defined and accessible. They can be passed as arguments to algorithm
73  * templates and used in place of a function pointer. Not only is the
74  * resulting expressiveness of the library increased, but the generated
75  * code can be more efficient than what you might write by hand. When we
76  * refer to @a functors, then, generally we include function pointers in
77  * the description as well.
78  *
79  * Often, functors are only created as temporaries passed to algorithm
80  * calls, rather than being created as named variables.
81  *
82  * Two examples taken from the standard itself follow. To perform a
83  * by-element addition of two vectors @c a and @c b containing @c double,
84  * and put the result in @c a, use
85  * \code
86  * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
87  * \endcode
88  * To negate every element in @c a, use
89  * \code
90  * transform(a.begin(), a.end(), a.begin(), negate<double>());
91  * \endcode
92  * The addition and negation functions will be inlined directly.
93  *
94  * The standard functors are derived from structs named @c unary_function
95  * and @c binary_function. These two classes contain nothing but typedefs,
96  * to aid in generic (template) programming. If you write your own
97  * functors, you might consider doing the same.
98  *
99  * @{
100  */
101  /**
102  * This is one of the @link functors functor base classes@endlink.
103  */
104  template<typename _Arg, typename _Result>
106  {
107  /// @c argument_type is the type of the argument
108  typedef _Arg argument_type;
109 
110  /// @c result_type is the return type
111  typedef _Result result_type;
112  };
113 
114  /**
115  * This is one of the @link functors functor base classes@endlink.
116  */
117  template<typename _Arg1, typename _Arg2, typename _Result>
119  {
120  /// @c first_argument_type is the type of the first argument
121  typedef _Arg1 first_argument_type;
122 
123  /// @c second_argument_type is the type of the second argument
124  typedef _Arg2 second_argument_type;
125 
126  /// @c result_type is the return type
127  typedef _Result result_type;
128  };
129  /** @} */
130 
131  // 20.3.2 arithmetic
132  /** @defgroup arithmetic_functors Arithmetic Classes
133  * @ingroup functors
134  *
135  * Because basic math often needs to be done during an algorithm,
136  * the library provides functors for those operations. See the
137  * documentation for @link functors the base classes@endlink
138  * for examples of their use.
139  *
140  * @{
141  */
142 
143 #if __cplusplus > 201103L
144  struct __is_transparent; // undefined
145 
146  template<typename _Tp = void>
147  struct plus;
148 
149  template<typename _Tp = void>
150  struct minus;
151 
152  template<typename _Tp = void>
153  struct multiplies;
154 
155  template<typename _Tp = void>
156  struct divides;
157 
158  template<typename _Tp = void>
159  struct modulus;
160 
161  template<typename _Tp = void>
162  struct negate;
163 #endif
164 
165  /// One of the @link arithmetic_functors math functors@endlink.
166  template<typename _Tp>
167  struct plus : public binary_function<_Tp, _Tp, _Tp>
168  {
169  _GLIBCXX14_CONSTEXPR
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 minus : public binary_function<_Tp, _Tp, _Tp>
178  {
179  _GLIBCXX14_CONSTEXPR
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 multiplies : public binary_function<_Tp, _Tp, _Tp>
188  {
189  _GLIBCXX14_CONSTEXPR
190  _Tp
191  operator()(const _Tp& __x, const _Tp& __y) const
192  { return __x * __y; }
193  };
194 
195  /// One of the @link arithmetic_functors math functors@endlink.
196  template<typename _Tp>
197  struct divides : public binary_function<_Tp, _Tp, _Tp>
198  {
199  _GLIBCXX14_CONSTEXPR
200  _Tp
201  operator()(const _Tp& __x, const _Tp& __y) const
202  { return __x / __y; }
203  };
204 
205  /// One of the @link arithmetic_functors math functors@endlink.
206  template<typename _Tp>
207  struct modulus : public binary_function<_Tp, _Tp, _Tp>
208  {
209  _GLIBCXX14_CONSTEXPR
210  _Tp
211  operator()(const _Tp& __x, const _Tp& __y) const
212  { return __x % __y; }
213  };
214 
215  /// One of the @link arithmetic_functors math functors@endlink.
216  template<typename _Tp>
217  struct negate : public unary_function<_Tp, _Tp>
218  {
219  _GLIBCXX14_CONSTEXPR
220  _Tp
221  operator()(const _Tp& __x) const
222  { return -__x; }
223  };
224 
225 #if __cplusplus > 201103L
226 
227 #define __cpp_lib_transparent_operators 201510
228 
229  template<>
230  struct plus<void>
231  {
232  template <typename _Tp, typename _Up>
233  _GLIBCXX14_CONSTEXPR
234  auto
235  operator()(_Tp&& __t, _Up&& __u) const
236  noexcept(noexcept(std::forward<_Tp>(__t) + std::forward<_Up>(__u)))
237  -> decltype(std::forward<_Tp>(__t) + std::forward<_Up>(__u))
238  { return std::forward<_Tp>(__t) + std::forward<_Up>(__u); }
239 
240  typedef __is_transparent is_transparent;
241  };
242 
243  /// One of the @link arithmetic_functors math functors@endlink.
244  template<>
245  struct minus<void>
246  {
247  template <typename _Tp, typename _Up>
248  _GLIBCXX14_CONSTEXPR
249  auto
250  operator()(_Tp&& __t, _Up&& __u) const
251  noexcept(noexcept(std::forward<_Tp>(__t) - std::forward<_Up>(__u)))
252  -> decltype(std::forward<_Tp>(__t) - std::forward<_Up>(__u))
253  { return std::forward<_Tp>(__t) - std::forward<_Up>(__u); }
254 
255  typedef __is_transparent is_transparent;
256  };
257 
258  /// One of the @link arithmetic_functors math functors@endlink.
259  template<>
260  struct multiplies<void>
261  {
262  template <typename _Tp, typename _Up>
263  _GLIBCXX14_CONSTEXPR
264  auto
265  operator()(_Tp&& __t, _Up&& __u) const
266  noexcept(noexcept(std::forward<_Tp>(__t) * std::forward<_Up>(__u)))
267  -> decltype(std::forward<_Tp>(__t) * std::forward<_Up>(__u))
268  { return std::forward<_Tp>(__t) * std::forward<_Up>(__u); }
269 
270  typedef __is_transparent is_transparent;
271  };
272 
273  /// One of the @link arithmetic_functors math functors@endlink.
274  template<>
275  struct divides<void>
276  {
277  template <typename _Tp, typename _Up>
278  _GLIBCXX14_CONSTEXPR
279  auto
280  operator()(_Tp&& __t, _Up&& __u) const
281  noexcept(noexcept(std::forward<_Tp>(__t) / std::forward<_Up>(__u)))
282  -> decltype(std::forward<_Tp>(__t) / std::forward<_Up>(__u))
283  { return std::forward<_Tp>(__t) / std::forward<_Up>(__u); }
284 
285  typedef __is_transparent is_transparent;
286  };
287 
288  /// One of the @link arithmetic_functors math functors@endlink.
289  template<>
290  struct modulus<void>
291  {
292  template <typename _Tp, typename _Up>
293  _GLIBCXX14_CONSTEXPR
294  auto
295  operator()(_Tp&& __t, _Up&& __u) const
296  noexcept(noexcept(std::forward<_Tp>(__t) % std::forward<_Up>(__u)))
297  -> decltype(std::forward<_Tp>(__t) % std::forward<_Up>(__u))
298  { return std::forward<_Tp>(__t) % std::forward<_Up>(__u); }
299 
300  typedef __is_transparent is_transparent;
301  };
302 
303  /// One of the @link arithmetic_functors math functors@endlink.
304  template<>
305  struct negate<void>
306  {
307  template <typename _Tp>
308  _GLIBCXX14_CONSTEXPR
309  auto
310  operator()(_Tp&& __t) const
311  noexcept(noexcept(-std::forward<_Tp>(__t)))
312  -> decltype(-std::forward<_Tp>(__t))
313  { return -std::forward<_Tp>(__t); }
314 
315  typedef __is_transparent is_transparent;
316  };
317 #endif
318  /** @} */
319 
320  // 20.3.3 comparisons
321  /** @defgroup comparison_functors Comparison Classes
322  * @ingroup functors
323  *
324  * The library provides six wrapper functors for all the basic comparisons
325  * in C++, like @c <.
326  *
327  * @{
328  */
329 #if __cplusplus > 201103L
330  template<typename _Tp = void>
331  struct equal_to;
332 
333  template<typename _Tp = void>
334  struct not_equal_to;
335 
336  template<typename _Tp = void>
337  struct greater;
338 
339  template<typename _Tp = void>
340  struct less;
341 
342  template<typename _Tp = void>
343  struct greater_equal;
344 
345  template<typename _Tp = void>
346  struct less_equal;
347 #endif
348 
349  /// One of the @link comparison_functors comparison functors@endlink.
350  template<typename _Tp>
351  struct equal_to : public binary_function<_Tp, _Tp, bool>
352  {
353  _GLIBCXX14_CONSTEXPR
354  bool
355  operator()(const _Tp& __x, const _Tp& __y) const
356  { return __x == __y; }
357  };
358 
359  /// One of the @link comparison_functors comparison functors@endlink.
360  template<typename _Tp>
361  struct not_equal_to : public binary_function<_Tp, _Tp, bool>
362  {
363  _GLIBCXX14_CONSTEXPR
364  bool
365  operator()(const _Tp& __x, const _Tp& __y) const
366  { return __x != __y; }
367  };
368 
369  /// One of the @link comparison_functors comparison functors@endlink.
370  template<typename _Tp>
371  struct greater : public binary_function<_Tp, _Tp, bool>
372  {
373  _GLIBCXX14_CONSTEXPR
374  bool
375  operator()(const _Tp& __x, const _Tp& __y) const
376  { return __x > __y; }
377  };
378 
379  /// One of the @link comparison_functors comparison functors@endlink.
380  template<typename _Tp>
381  struct less : public binary_function<_Tp, _Tp, bool>
382  {
383  _GLIBCXX14_CONSTEXPR
384  bool
385  operator()(const _Tp& __x, const _Tp& __y) const
386  { return __x < __y; }
387  };
388 
389  /// One of the @link comparison_functors comparison functors@endlink.
390  template<typename _Tp>
391  struct greater_equal : public binary_function<_Tp, _Tp, bool>
392  {
393  _GLIBCXX14_CONSTEXPR
394  bool
395  operator()(const _Tp& __x, const _Tp& __y) const
396  { return __x >= __y; }
397  };
398 
399  /// One of the @link comparison_functors comparison functors@endlink.
400  template<typename _Tp>
401  struct less_equal : public binary_function<_Tp, _Tp, bool>
402  {
403  _GLIBCXX14_CONSTEXPR
404  bool
405  operator()(const _Tp& __x, const _Tp& __y) const
406  { return __x <= __y; }
407  };
408 
409  // Partial specialization of std::greater for pointers.
410  template<typename _Tp>
411  struct greater<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
412  {
413  _GLIBCXX14_CONSTEXPR bool
414  operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
415  {
416  if (__builtin_constant_p (__x > __y))
417  return __x > __y;
418  return (__UINTPTR_TYPE__)__x > (__UINTPTR_TYPE__)__y;
419  }
420  };
421 
422  // Partial specialization of std::less for pointers.
423  template<typename _Tp>
424  struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
425  {
426  _GLIBCXX14_CONSTEXPR bool
427  operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
428  {
429  if (__builtin_constant_p (__x < __y))
430  return __x < __y;
431  return (__UINTPTR_TYPE__)__x < (__UINTPTR_TYPE__)__y;
432  }
433  };
434 
435  // Partial specialization of std::greater_equal for pointers.
436  template<typename _Tp>
437  struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
438  {
439  _GLIBCXX14_CONSTEXPR bool
440  operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
441  {
442  if (__builtin_constant_p (__x >= __y))
443  return __x >= __y;
444  return (__UINTPTR_TYPE__)__x >= (__UINTPTR_TYPE__)__y;
445  }
446  };
447 
448  // Partial specialization of std::less_equal for pointers.
449  template<typename _Tp>
450  struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
451  {
452  _GLIBCXX14_CONSTEXPR bool
453  operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
454  {
455  if (__builtin_constant_p (__x <= __y))
456  return __x <= __y;
457  return (__UINTPTR_TYPE__)__x <= (__UINTPTR_TYPE__)__y;
458  }
459  };
460 
461 #if __cplusplus >= 201402L
462  /// One of the @link comparison_functors comparison functors@endlink.
463  template<>
464  struct equal_to<void>
465  {
466  template <typename _Tp, typename _Up>
467  constexpr auto
468  operator()(_Tp&& __t, _Up&& __u) const
469  noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
470  -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
471  { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
472 
473  typedef __is_transparent is_transparent;
474  };
475 
476  /// One of the @link comparison_functors comparison functors@endlink.
477  template<>
478  struct not_equal_to<void>
479  {
480  template <typename _Tp, typename _Up>
481  constexpr auto
482  operator()(_Tp&& __t, _Up&& __u) const
483  noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
484  -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
485  { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
486 
487  typedef __is_transparent is_transparent;
488  };
489 
490  /// One of the @link comparison_functors comparison functors@endlink.
491  template<>
492  struct greater<void>
493  {
494  template <typename _Tp, typename _Up>
495  constexpr auto
496  operator()(_Tp&& __t, _Up&& __u) const
497  noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
498  -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
499  {
500  return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
501  __ptr_cmp<_Tp, _Up>{});
502  }
503 
504  template<typename _Tp, typename _Up>
505  constexpr bool
506  operator()(_Tp* __t, _Up* __u) const noexcept
507  { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
508 
509  typedef __is_transparent is_transparent;
510 
511  private:
512  template <typename _Tp, typename _Up>
513  static constexpr decltype(auto)
514  _S_cmp(_Tp&& __t, _Up&& __u, false_type)
515  { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
516 
517  template <typename _Tp, typename _Up>
518  static constexpr bool
519  _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
520  {
522  static_cast<const volatile void*>(std::forward<_Tp>(__t)),
523  static_cast<const volatile void*>(std::forward<_Up>(__u)));
524  }
525 
526  // True if there is no viable operator> member function.
527  template<typename _Tp, typename _Up, typename = void>
528  struct __not_overloaded2 : true_type { };
529 
530  // False if we can call T.operator>(U)
531  template<typename _Tp, typename _Up>
532  struct __not_overloaded2<_Tp, _Up, __void_t<
533  decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
534  : false_type { };
535 
536  // True if there is no overloaded operator> for these operands.
537  template<typename _Tp, typename _Up, typename = void>
538  struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
539 
540  // False if we can call operator>(T,U)
541  template<typename _Tp, typename _Up>
542  struct __not_overloaded<_Tp, _Up, __void_t<
543  decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
544  : false_type { };
545 
546  template<typename _Tp, typename _Up>
547  using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
550  };
551 
552  /// One of the @link comparison_functors comparison functors@endlink.
553  template<>
554  struct less<void>
555  {
556  template <typename _Tp, typename _Up>
557  constexpr auto
558  operator()(_Tp&& __t, _Up&& __u) const
559  noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
560  -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
561  {
562  return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
563  __ptr_cmp<_Tp, _Up>{});
564  }
565 
566  template<typename _Tp, typename _Up>
567  constexpr bool
568  operator()(_Tp* __t, _Up* __u) const noexcept
569  { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
570 
571  typedef __is_transparent is_transparent;
572 
573  private:
574  template <typename _Tp, typename _Up>
575  static constexpr decltype(auto)
576  _S_cmp(_Tp&& __t, _Up&& __u, false_type)
577  { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
578 
579  template <typename _Tp, typename _Up>
580  static constexpr bool
581  _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
582  {
584  static_cast<const volatile void*>(std::forward<_Tp>(__t)),
585  static_cast<const volatile void*>(std::forward<_Up>(__u)));
586  }
587 
588  // True if there is no viable operator< member function.
589  template<typename _Tp, typename _Up, typename = void>
590  struct __not_overloaded2 : true_type { };
591 
592  // False if we can call T.operator<(U)
593  template<typename _Tp, typename _Up>
594  struct __not_overloaded2<_Tp, _Up, __void_t<
595  decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
596  : false_type { };
597 
598  // True if there is no overloaded operator< for these operands.
599  template<typename _Tp, typename _Up, typename = void>
600  struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
601 
602  // False if we can call operator<(T,U)
603  template<typename _Tp, typename _Up>
604  struct __not_overloaded<_Tp, _Up, __void_t<
605  decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
606  : false_type { };
607 
608  template<typename _Tp, typename _Up>
609  using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
612  };
613 
614  /// One of the @link comparison_functors comparison functors@endlink.
615  template<>
616  struct greater_equal<void>
617  {
618  template <typename _Tp, typename _Up>
619  constexpr auto
620  operator()(_Tp&& __t, _Up&& __u) const
621  noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
622  -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
623  {
624  return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
625  __ptr_cmp<_Tp, _Up>{});
626  }
627 
628  template<typename _Tp, typename _Up>
629  constexpr bool
630  operator()(_Tp* __t, _Up* __u) const noexcept
631  { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
632 
633  typedef __is_transparent is_transparent;
634 
635  private:
636  template <typename _Tp, typename _Up>
637  static constexpr decltype(auto)
638  _S_cmp(_Tp&& __t, _Up&& __u, false_type)
639  { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
640 
641  template <typename _Tp, typename _Up>
642  static constexpr bool
643  _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
644  {
646  static_cast<const volatile void*>(std::forward<_Tp>(__t)),
647  static_cast<const volatile void*>(std::forward<_Up>(__u)));
648  }
649 
650  // True if there is no viable operator>= member function.
651  template<typename _Tp, typename _Up, typename = void>
652  struct __not_overloaded2 : true_type { };
653 
654  // False if we can call T.operator>=(U)
655  template<typename _Tp, typename _Up>
656  struct __not_overloaded2<_Tp, _Up, __void_t<
657  decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
658  : false_type { };
659 
660  // True if there is no overloaded operator>= for these operands.
661  template<typename _Tp, typename _Up, typename = void>
662  struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
663 
664  // False if we can call operator>=(T,U)
665  template<typename _Tp, typename _Up>
666  struct __not_overloaded<_Tp, _Up, __void_t<
667  decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
668  : false_type { };
669 
670  template<typename _Tp, typename _Up>
671  using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
674  };
675 
676  /// One of the @link comparison_functors comparison functors@endlink.
677  template<>
678  struct less_equal<void>
679  {
680  template <typename _Tp, typename _Up>
681  constexpr auto
682  operator()(_Tp&& __t, _Up&& __u) const
683  noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
684  -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
685  {
686  return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
687  __ptr_cmp<_Tp, _Up>{});
688  }
689 
690  template<typename _Tp, typename _Up>
691  constexpr bool
692  operator()(_Tp* __t, _Up* __u) const noexcept
693  { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
694 
695  typedef __is_transparent is_transparent;
696 
697  private:
698  template <typename _Tp, typename _Up>
699  static constexpr decltype(auto)
700  _S_cmp(_Tp&& __t, _Up&& __u, false_type)
701  { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
702 
703  template <typename _Tp, typename _Up>
704  static constexpr bool
705  _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
706  {
708  static_cast<const volatile void*>(std::forward<_Tp>(__t)),
709  static_cast<const volatile void*>(std::forward<_Up>(__u)));
710  }
711 
712  // True if there is no viable operator<= member function.
713  template<typename _Tp, typename _Up, typename = void>
714  struct __not_overloaded2 : true_type { };
715 
716  // False if we can call T.operator<=(U)
717  template<typename _Tp, typename _Up>
718  struct __not_overloaded2<_Tp, _Up, __void_t<
719  decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
720  : false_type { };
721 
722  // True if there is no overloaded operator<= for these operands.
723  template<typename _Tp, typename _Up, typename = void>
724  struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
725 
726  // False if we can call operator<=(T,U)
727  template<typename _Tp, typename _Up>
728  struct __not_overloaded<_Tp, _Up, __void_t<
729  decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
730  : false_type { };
731 
732  template<typename _Tp, typename _Up>
733  using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
736  };
737 #endif // C++14
738  /** @} */
739 
740  // 20.3.4 logical operations
741  /** @defgroup logical_functors Boolean Operations Classes
742  * @ingroup functors
743  *
744  * Here are wrapper functors for Boolean operations: @c &&, @c ||,
745  * and @c !.
746  *
747  * @{
748  */
749 #if __cplusplus > 201103L
750  template<typename _Tp = void>
751  struct logical_and;
752 
753  template<typename _Tp = void>
754  struct logical_or;
755 
756  template<typename _Tp = void>
757  struct logical_not;
758 #endif
759 
760  /// One of the @link logical_functors Boolean operations functors@endlink.
761  template<typename _Tp>
762  struct logical_and : public binary_function<_Tp, _Tp, bool>
763  {
764  _GLIBCXX14_CONSTEXPR
765  bool
766  operator()(const _Tp& __x, const _Tp& __y) const
767  { return __x && __y; }
768  };
769 
770  /// One of the @link logical_functors Boolean operations functors@endlink.
771  template<typename _Tp>
772  struct logical_or : public binary_function<_Tp, _Tp, bool>
773  {
774  _GLIBCXX14_CONSTEXPR
775  bool
776  operator()(const _Tp& __x, const _Tp& __y) const
777  { return __x || __y; }
778  };
779 
780  /// One of the @link logical_functors Boolean operations functors@endlink.
781  template<typename _Tp>
782  struct logical_not : public unary_function<_Tp, bool>
783  {
784  _GLIBCXX14_CONSTEXPR
785  bool
786  operator()(const _Tp& __x) const
787  { return !__x; }
788  };
789 
790 #if __cplusplus > 201103L
791  /// One of the @link logical_functors Boolean operations functors@endlink.
792  template<>
793  struct logical_and<void>
794  {
795  template <typename _Tp, typename _Up>
796  _GLIBCXX14_CONSTEXPR
797  auto
798  operator()(_Tp&& __t, _Up&& __u) const
799  noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
800  -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
801  { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
802 
803  typedef __is_transparent is_transparent;
804  };
805 
806  /// One of the @link logical_functors Boolean operations functors@endlink.
807  template<>
808  struct logical_or<void>
809  {
810  template <typename _Tp, typename _Up>
811  _GLIBCXX14_CONSTEXPR
812  auto
813  operator()(_Tp&& __t, _Up&& __u) const
814  noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
815  -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
816  { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
817 
818  typedef __is_transparent is_transparent;
819  };
820 
821  /// One of the @link logical_functors Boolean operations functors@endlink.
822  template<>
823  struct logical_not<void>
824  {
825  template <typename _Tp>
826  _GLIBCXX14_CONSTEXPR
827  auto
828  operator()(_Tp&& __t) const
829  noexcept(noexcept(!std::forward<_Tp>(__t)))
830  -> decltype(!std::forward<_Tp>(__t))
831  { return !std::forward<_Tp>(__t); }
832 
833  typedef __is_transparent is_transparent;
834  };
835 #endif
836  /** @} */
837 
838 #if __cplusplus > 201103L
839  template<typename _Tp = void>
840  struct bit_and;
841 
842  template<typename _Tp = void>
843  struct bit_or;
844 
845  template<typename _Tp = void>
846  struct bit_xor;
847 
848  template<typename _Tp = void>
849  struct bit_not;
850 #endif
851 
852  // _GLIBCXX_RESOLVE_LIB_DEFECTS
853  // DR 660. Missing Bitwise Operations.
854  template<typename _Tp>
855  struct bit_and : public binary_function<_Tp, _Tp, _Tp>
856  {
857  _GLIBCXX14_CONSTEXPR
858  _Tp
859  operator()(const _Tp& __x, const _Tp& __y) const
860  { return __x & __y; }
861  };
862 
863  template<typename _Tp>
864  struct bit_or : public binary_function<_Tp, _Tp, _Tp>
865  {
866  _GLIBCXX14_CONSTEXPR
867  _Tp
868  operator()(const _Tp& __x, const _Tp& __y) const
869  { return __x | __y; }
870  };
871 
872  template<typename _Tp>
873  struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
874  {
875  _GLIBCXX14_CONSTEXPR
876  _Tp
877  operator()(const _Tp& __x, const _Tp& __y) const
878  { return __x ^ __y; }
879  };
880 
881  template<typename _Tp>
882  struct bit_not : public unary_function<_Tp, _Tp>
883  {
884  _GLIBCXX14_CONSTEXPR
885  _Tp
886  operator()(const _Tp& __x) const
887  { return ~__x; }
888  };
889 
890 #if __cplusplus > 201103L
891  template <>
892  struct bit_and<void>
893  {
894  template <typename _Tp, typename _Up>
895  _GLIBCXX14_CONSTEXPR
896  auto
897  operator()(_Tp&& __t, _Up&& __u) const
898  noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
899  -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
900  { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
901 
902  typedef __is_transparent is_transparent;
903  };
904 
905  template <>
906  struct bit_or<void>
907  {
908  template <typename _Tp, typename _Up>
909  _GLIBCXX14_CONSTEXPR
910  auto
911  operator()(_Tp&& __t, _Up&& __u) const
912  noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
913  -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
914  { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
915 
916  typedef __is_transparent is_transparent;
917  };
918 
919  template <>
920  struct bit_xor<void>
921  {
922  template <typename _Tp, typename _Up>
923  _GLIBCXX14_CONSTEXPR
924  auto
925  operator()(_Tp&& __t, _Up&& __u) const
926  noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
927  -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
928  { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
929 
930  typedef __is_transparent is_transparent;
931  };
932 
933  template <>
934  struct bit_not<void>
935  {
936  template <typename _Tp>
937  _GLIBCXX14_CONSTEXPR
938  auto
939  operator()(_Tp&& __t) const
940  noexcept(noexcept(~std::forward<_Tp>(__t)))
941  -> decltype(~std::forward<_Tp>(__t))
942  { return ~std::forward<_Tp>(__t); }
943 
944  typedef __is_transparent is_transparent;
945  };
946 #endif
947 
948  // 20.3.5 negators
949  /** @defgroup negators Negators
950  * @ingroup functors
951  *
952  * The functions @c not1 and @c not2 each take a predicate functor
953  * and return an instance of @c unary_negate or
954  * @c binary_negate, respectively. These classes are functors whose
955  * @c operator() performs the stored predicate function and then returns
956  * the negation of the result.
957  *
958  * For example, given a vector of integers and a trivial predicate,
959  * \code
960  * struct IntGreaterThanThree
961  * : public std::unary_function<int, bool>
962  * {
963  * bool operator() (int x) { return x > 3; }
964  * };
965  *
966  * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
967  * \endcode
968  * The call to @c find_if will locate the first index (i) of @c v for which
969  * <code>!(v[i] > 3)</code> is true.
970  *
971  * The not1/unary_negate combination works on predicates taking a single
972  * argument. The not2/binary_negate combination works on predicates which
973  * take two arguments.
974  *
975  * @{
976  */
977  /// One of the @link negators negation functors@endlink.
978  template<typename _Predicate>
980  : public unary_function<typename _Predicate::argument_type, bool>
981  {
982  protected:
983  _Predicate _M_pred;
984 
985  public:
986  _GLIBCXX14_CONSTEXPR
987  explicit
988  unary_negate(const _Predicate& __x) : _M_pred(__x) { }
989 
990  _GLIBCXX14_CONSTEXPR
991  bool
992  operator()(const typename _Predicate::argument_type& __x) const
993  { return !_M_pred(__x); }
994  };
995 
996  /// One of the @link negators negation functors@endlink.
997  template<typename _Predicate>
998  _GLIBCXX14_CONSTEXPR
1000  not1(const _Predicate& __pred)
1001  { return unary_negate<_Predicate>(__pred); }
1002 
1003  /// One of the @link negators negation functors@endlink.
1004  template<typename _Predicate>
1006  : public binary_function<typename _Predicate::first_argument_type,
1007  typename _Predicate::second_argument_type, bool>
1008  {
1009  protected:
1010  _Predicate _M_pred;
1011 
1012  public:
1013  _GLIBCXX14_CONSTEXPR
1014  explicit
1015  binary_negate(const _Predicate& __x) : _M_pred(__x) { }
1016 
1017  _GLIBCXX14_CONSTEXPR
1018  bool
1019  operator()(const typename _Predicate::first_argument_type& __x,
1020  const typename _Predicate::second_argument_type& __y) const
1021  { return !_M_pred(__x, __y); }
1022  };
1023 
1024  /// One of the @link negators negation functors@endlink.
1025  template<typename _Predicate>
1026  _GLIBCXX14_CONSTEXPR
1028  not2(const _Predicate& __pred)
1029  { return binary_negate<_Predicate>(__pred); }
1030  /** @} */
1031 
1032  // 20.3.7 adaptors pointers functions
1033  /** @defgroup pointer_adaptors Adaptors for pointers to functions
1034  * @ingroup functors
1035  *
1036  * The advantage of function objects over pointers to functions is that
1037  * the objects in the standard library declare nested typedefs describing
1038  * their argument and result types with uniform names (e.g., @c result_type
1039  * from the base classes @c unary_function and @c binary_function).
1040  * Sometimes those typedefs are required, not just optional.
1041  *
1042  * Adaptors are provided to turn pointers to unary (single-argument) and
1043  * binary (double-argument) functions into function objects. The
1044  * long-winded functor @c pointer_to_unary_function is constructed with a
1045  * function pointer @c f, and its @c operator() called with argument @c x
1046  * returns @c f(x). The functor @c pointer_to_binary_function does the same
1047  * thing, but with a double-argument @c f and @c operator().
1048  *
1049  * The function @c ptr_fun takes a pointer-to-function @c f and constructs
1050  * an instance of the appropriate functor.
1051  *
1052  * @{
1053  */
1054  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1055  template<typename _Arg, typename _Result>
1056  class pointer_to_unary_function : public unary_function<_Arg, _Result>
1057  {
1058  protected:
1059  _Result (*_M_ptr)(_Arg);
1060 
1061  public:
1063 
1064  explicit
1065  pointer_to_unary_function(_Result (*__x)(_Arg))
1066  : _M_ptr(__x) { }
1067 
1068  _Result
1069  operator()(_Arg __x) const
1070  { return _M_ptr(__x); }
1071  };
1072 
1073  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1074  template<typename _Arg, typename _Result>
1076  ptr_fun(_Result (*__x)(_Arg))
1078 
1079  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1080  template<typename _Arg1, typename _Arg2, typename _Result>
1082  : public binary_function<_Arg1, _Arg2, _Result>
1083  {
1084  protected:
1085  _Result (*_M_ptr)(_Arg1, _Arg2);
1086 
1087  public:
1089 
1090  explicit
1091  pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
1092  : _M_ptr(__x) { }
1093 
1094  _Result
1095  operator()(_Arg1 __x, _Arg2 __y) const
1096  { return _M_ptr(__x, __y); }
1097  };
1098 
1099  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1100  template<typename _Arg1, typename _Arg2, typename _Result>
1102  ptr_fun(_Result (*__x)(_Arg1, _Arg2))
1104  /** @} */
1105 
1106  template<typename _Tp>
1107  struct _Identity
1108  : public unary_function<_Tp, _Tp>
1109  {
1110  _Tp&
1111  operator()(_Tp& __x) const
1112  { return __x; }
1113 
1114  const _Tp&
1115  operator()(const _Tp& __x) const
1116  { return __x; }
1117  };
1118 
1119  // Partial specialization, avoids confusing errors in e.g. std::set<const T>.
1120  template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };
1121 
1122  template<typename _Pair>
1123  struct _Select1st
1124  : public unary_function<_Pair, typename _Pair::first_type>
1125  {
1126  typename _Pair::first_type&
1127  operator()(_Pair& __x) const
1128  { return __x.first; }
1129 
1130  const typename _Pair::first_type&
1131  operator()(const _Pair& __x) const
1132  { return __x.first; }
1133 
1134 #if __cplusplus >= 201103L
1135  template<typename _Pair2>
1136  typename _Pair2::first_type&
1137  operator()(_Pair2& __x) const
1138  { return __x.first; }
1139 
1140  template<typename _Pair2>
1141  const typename _Pair2::first_type&
1142  operator()(const _Pair2& __x) const
1143  { return __x.first; }
1144 #endif
1145  };
1146 
1147  template<typename _Pair>
1148  struct _Select2nd
1149  : public unary_function<_Pair, typename _Pair::second_type>
1150  {
1151  typename _Pair::second_type&
1152  operator()(_Pair& __x) const
1153  { return __x.second; }
1154 
1155  const typename _Pair::second_type&
1156  operator()(const _Pair& __x) const
1157  { return __x.second; }
1158  };
1159 
1160  // 20.3.8 adaptors pointers members
1161  /** @defgroup memory_adaptors Adaptors for pointers to members
1162  * @ingroup functors
1163  *
1164  * There are a total of 8 = 2^3 function objects in this family.
1165  * (1) Member functions taking no arguments vs member functions taking
1166  * one argument.
1167  * (2) Call through pointer vs call through reference.
1168  * (3) Const vs non-const member function.
1169  *
1170  * All of this complexity is in the function objects themselves. You can
1171  * ignore it by using the helper function mem_fun and mem_fun_ref,
1172  * which create whichever type of adaptor is appropriate.
1173  *
1174  * @{
1175  */
1176  /// One of the @link memory_adaptors adaptors for member
1177  /// pointers@endlink.
1178  template<typename _Ret, typename _Tp>
1179  class mem_fun_t : public unary_function<_Tp*, _Ret>
1180  {
1181  public:
1182  explicit
1183  mem_fun_t(_Ret (_Tp::*__pf)())
1184  : _M_f(__pf) { }
1185 
1186  _Ret
1187  operator()(_Tp* __p) const
1188  { return (__p->*_M_f)(); }
1189 
1190  private:
1191  _Ret (_Tp::*_M_f)();
1192  };
1193 
1194  /// One of the @link memory_adaptors adaptors for member
1195  /// pointers@endlink.
1196  template<typename _Ret, typename _Tp>
1197  class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
1198  {
1199  public:
1200  explicit
1201  const_mem_fun_t(_Ret (_Tp::*__pf)() const)
1202  : _M_f(__pf) { }
1203 
1204  _Ret
1205  operator()(const _Tp* __p) const
1206  { return (__p->*_M_f)(); }
1207 
1208  private:
1209  _Ret (_Tp::*_M_f)() const;
1210  };
1211 
1212  /// One of the @link memory_adaptors adaptors for member
1213  /// pointers@endlink.
1214  template<typename _Ret, typename _Tp>
1215  class mem_fun_ref_t : public unary_function<_Tp, _Ret>
1216  {
1217  public:
1218  explicit
1219  mem_fun_ref_t(_Ret (_Tp::*__pf)())
1220  : _M_f(__pf) { }
1221 
1222  _Ret
1223  operator()(_Tp& __r) const
1224  { return (__r.*_M_f)(); }
1225 
1226  private:
1227  _Ret (_Tp::*_M_f)();
1228  };
1229 
1230  /// One of the @link memory_adaptors adaptors for member
1231  /// pointers@endlink.
1232  template<typename _Ret, typename _Tp>
1233  class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
1234  {
1235  public:
1236  explicit
1237  const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
1238  : _M_f(__pf) { }
1239 
1240  _Ret
1241  operator()(const _Tp& __r) const
1242  { return (__r.*_M_f)(); }
1243 
1244  private:
1245  _Ret (_Tp::*_M_f)() const;
1246  };
1247 
1248  /// One of the @link memory_adaptors adaptors for member
1249  /// pointers@endlink.
1250  template<typename _Ret, typename _Tp, typename _Arg>
1251  class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
1252  {
1253  public:
1254  explicit
1255  mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
1256  : _M_f(__pf) { }
1257 
1258  _Ret
1259  operator()(_Tp* __p, _Arg __x) const
1260  { return (__p->*_M_f)(__x); }
1261 
1262  private:
1263  _Ret (_Tp::*_M_f)(_Arg);
1264  };
1265 
1266  /// One of the @link memory_adaptors adaptors for member
1267  /// pointers@endlink.
1268  template<typename _Ret, typename _Tp, typename _Arg>
1269  class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
1270  {
1271  public:
1272  explicit
1273  const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
1274  : _M_f(__pf) { }
1275 
1276  _Ret
1277  operator()(const _Tp* __p, _Arg __x) const
1278  { return (__p->*_M_f)(__x); }
1279 
1280  private:
1281  _Ret (_Tp::*_M_f)(_Arg) const;
1282  };
1283 
1284  /// One of the @link memory_adaptors adaptors for member
1285  /// pointers@endlink.
1286  template<typename _Ret, typename _Tp, typename _Arg>
1287  class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1288  {
1289  public:
1290  explicit
1291  mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
1292  : _M_f(__pf) { }
1293 
1294  _Ret
1295  operator()(_Tp& __r, _Arg __x) const
1296  { return (__r.*_M_f)(__x); }
1297 
1298  private:
1299  _Ret (_Tp::*_M_f)(_Arg);
1300  };
1301 
1302  /// One of the @link memory_adaptors adaptors for member
1303  /// pointers@endlink.
1304  template<typename _Ret, typename _Tp, typename _Arg>
1305  class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1306  {
1307  public:
1308  explicit
1309  const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
1310  : _M_f(__pf) { }
1311 
1312  _Ret
1313  operator()(const _Tp& __r, _Arg __x) const
1314  { return (__r.*_M_f)(__x); }
1315 
1316  private:
1317  _Ret (_Tp::*_M_f)(_Arg) const;
1318  };
1319 
1320  // Mem_fun adaptor helper functions. There are only two:
1321  // mem_fun and mem_fun_ref.
1322  template<typename _Ret, typename _Tp>
1323  inline mem_fun_t<_Ret, _Tp>
1324  mem_fun(_Ret (_Tp::*__f)())
1325  { return mem_fun_t<_Ret, _Tp>(__f); }
1326 
1327  template<typename _Ret, typename _Tp>
1328  inline const_mem_fun_t<_Ret, _Tp>
1329  mem_fun(_Ret (_Tp::*__f)() const)
1330  { return const_mem_fun_t<_Ret, _Tp>(__f); }
1331 
1332  template<typename _Ret, typename _Tp>
1333  inline mem_fun_ref_t<_Ret, _Tp>
1334  mem_fun_ref(_Ret (_Tp::*__f)())
1335  { return mem_fun_ref_t<_Ret, _Tp>(__f); }
1336 
1337  template<typename _Ret, typename _Tp>
1338  inline const_mem_fun_ref_t<_Ret, _Tp>
1339  mem_fun_ref(_Ret (_Tp::*__f)() const)
1340  { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
1341 
1342  template<typename _Ret, typename _Tp, typename _Arg>
1343  inline mem_fun1_t<_Ret, _Tp, _Arg>
1344  mem_fun(_Ret (_Tp::*__f)(_Arg))
1345  { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1346 
1347  template<typename _Ret, typename _Tp, typename _Arg>
1348  inline const_mem_fun1_t<_Ret, _Tp, _Arg>
1349  mem_fun(_Ret (_Tp::*__f)(_Arg) const)
1350  { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1351 
1352  template<typename _Ret, typename _Tp, typename _Arg>
1353  inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
1354  mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
1355  { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1356 
1357  template<typename _Ret, typename _Tp, typename _Arg>
1358  inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
1359  mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
1360  { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1361 
1362  /** @} */
1363 
1364 _GLIBCXX_END_NAMESPACE_VERSION
1365 } // namespace
1366 
1367 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1368 # include <backward/binders.h>
1369 #endif
1370 
1371 #endif /* _STL_FUNCTION_H */
_GLIBCXX14_CONSTEXPR binary_negate< _Predicate > not2(const _Predicate &__pred)
One of the negation functors.
_GLIBCXX14_CONSTEXPR unary_negate< _Predicate > not1(const _Predicate &__pred)
One of the negation functors.
pointer_to_unary_function< _Arg, _Result > ptr_fun(_Result(*__x)(_Arg))
One of the adaptors for function pointers.
ISO C++ entities toplevel namespace is std.
integral_constant
Definition: type_traits:58
is_convertible
Definition: type_traits:1329
_Arg argument_type
argument_type is the type of the argument
Definition: stl_function.h:108
_Result result_type
result_type is the return type
Definition: stl_function.h:111
_Result result_type
result_type is the return type
Definition: stl_function.h:127
_Arg2 second_argument_type
second_argument_type is the type of the second argument
Definition: stl_function.h:124
_Arg1 first_argument_type
first_argument_type is the type of the first argument
Definition: stl_function.h:121
One of the math functors.
Definition: stl_function.h:168
One of the math functors.
Definition: stl_function.h:178
One of the math functors.
Definition: stl_function.h:188
One of the math functors.
Definition: stl_function.h:198
One of the math functors.
Definition: stl_function.h:208
One of the math functors.
Definition: stl_function.h:218
One of the comparison functors.
Definition: stl_function.h:352
One of the comparison functors.
Definition: stl_function.h:362
One of the comparison functors.
Definition: stl_function.h:372
One of the comparison functors.
Definition: stl_function.h:382
One of the comparison functors.
Definition: stl_function.h:392
One of the comparison functors.
Definition: stl_function.h:402
One of the Boolean operations functors.
Definition: stl_function.h:763
One of the Boolean operations functors.
Definition: stl_function.h:773
One of the Boolean operations functors.
Definition: stl_function.h:783
One of the negation functors.
Definition: stl_function.h:981
One of the negation functors.
One of the adaptors for function pointers.
One of the adaptors for function pointers.
One of the adaptors for member pointers.
One of the adaptors for member pointers.
One of the adaptors for member pointers.
One of the adaptors for member pointers.
One of the adaptors for member pointers.
One of the adaptors for member pointers.
One of the adaptors for member pointers.
One of the adaptors for member pointers.