libstdc++
stl_function.h
Go to the documentation of this file.
1// Functor implementations -*- C++ -*-
2
3// Copyright (C) 2001-2019 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
63namespace 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 __cplusplus >= 201402L
417#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
418 if (__builtin_is_constant_evaluated())
419#else
420 if (__builtin_constant_p(__x > __y))
421#endif
422 return __x > __y;
423#endif
424 return (__UINTPTR_TYPE__)__x > (__UINTPTR_TYPE__)__y;
425 }
426 };
427
428 // Partial specialization of std::less for pointers.
429 template<typename _Tp>
430 struct less<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
431 {
432 _GLIBCXX14_CONSTEXPR bool
433 operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
434 {
435#if __cplusplus >= 201402L
436#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
437 if (__builtin_is_constant_evaluated())
438#else
439 if (__builtin_constant_p(__x < __y))
440#endif
441 return __x < __y;
442#endif
443 return (__UINTPTR_TYPE__)__x < (__UINTPTR_TYPE__)__y;
444 }
445 };
446
447 // Partial specialization of std::greater_equal for pointers.
448 template<typename _Tp>
449 struct greater_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
450 {
451 _GLIBCXX14_CONSTEXPR bool
452 operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
453 {
454#if __cplusplus >= 201402L
455#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
456 if (__builtin_is_constant_evaluated())
457#else
458 if (__builtin_constant_p(__x >= __y))
459#endif
460 return __x >= __y;
461#endif
462 return (__UINTPTR_TYPE__)__x >= (__UINTPTR_TYPE__)__y;
463 }
464 };
465
466 // Partial specialization of std::less_equal for pointers.
467 template<typename _Tp>
468 struct less_equal<_Tp*> : public binary_function<_Tp*, _Tp*, bool>
469 {
470 _GLIBCXX14_CONSTEXPR bool
471 operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
472 {
473#if __cplusplus >= 201402L
474#ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
475 if (__builtin_is_constant_evaluated())
476#else
477 if (__builtin_constant_p(__x <= __y))
478#endif
479 return __x <= __y;
480#endif
481 return (__UINTPTR_TYPE__)__x <= (__UINTPTR_TYPE__)__y;
482 }
483 };
484
485#if __cplusplus >= 201402L
486 /// One of the @link comparison_functors comparison functors@endlink.
487 template<>
488 struct equal_to<void>
489 {
490 template <typename _Tp, typename _Up>
491 constexpr auto
492 operator()(_Tp&& __t, _Up&& __u) const
493 noexcept(noexcept(std::forward<_Tp>(__t) == std::forward<_Up>(__u)))
494 -> decltype(std::forward<_Tp>(__t) == std::forward<_Up>(__u))
495 { return std::forward<_Tp>(__t) == std::forward<_Up>(__u); }
496
497 typedef __is_transparent is_transparent;
498 };
499
500 /// One of the @link comparison_functors comparison functors@endlink.
501 template<>
502 struct not_equal_to<void>
503 {
504 template <typename _Tp, typename _Up>
505 constexpr auto
506 operator()(_Tp&& __t, _Up&& __u) const
507 noexcept(noexcept(std::forward<_Tp>(__t) != std::forward<_Up>(__u)))
508 -> decltype(std::forward<_Tp>(__t) != std::forward<_Up>(__u))
509 { return std::forward<_Tp>(__t) != std::forward<_Up>(__u); }
510
511 typedef __is_transparent is_transparent;
512 };
513
514 /// One of the @link comparison_functors comparison functors@endlink.
515 template<>
516 struct greater<void>
517 {
518 template <typename _Tp, typename _Up>
519 constexpr auto
520 operator()(_Tp&& __t, _Up&& __u) const
521 noexcept(noexcept(std::forward<_Tp>(__t) > std::forward<_Up>(__u)))
522 -> decltype(std::forward<_Tp>(__t) > std::forward<_Up>(__u))
523 {
524 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
525 __ptr_cmp<_Tp, _Up>{});
526 }
527
528 template<typename _Tp, typename _Up>
529 constexpr bool
530 operator()(_Tp* __t, _Up* __u) const noexcept
531 { return greater<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
532
533 typedef __is_transparent is_transparent;
534
535 private:
536 template <typename _Tp, typename _Up>
537 static constexpr decltype(auto)
538 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
539 { return std::forward<_Tp>(__t) > std::forward<_Up>(__u); }
540
541 template <typename _Tp, typename _Up>
542 static constexpr bool
543 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
544 {
546 static_cast<const volatile void*>(std::forward<_Tp>(__t)),
547 static_cast<const volatile void*>(std::forward<_Up>(__u)));
548 }
549
550 // True if there is no viable operator> member function.
551 template<typename _Tp, typename _Up, typename = void>
552 struct __not_overloaded2 : true_type { };
553
554 // False if we can call T.operator>(U)
555 template<typename _Tp, typename _Up>
556 struct __not_overloaded2<_Tp, _Up, __void_t<
557 decltype(std::declval<_Tp>().operator>(std::declval<_Up>()))>>
558 : false_type { };
559
560 // True if there is no overloaded operator> for these operands.
561 template<typename _Tp, typename _Up, typename = void>
562 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
563
564 // False if we can call operator>(T,U)
565 template<typename _Tp, typename _Up>
566 struct __not_overloaded<_Tp, _Up, __void_t<
567 decltype(operator>(std::declval<_Tp>(), std::declval<_Up>()))>>
568 : false_type { };
569
570 template<typename _Tp, typename _Up>
571 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
574 };
575
576 /// One of the @link comparison_functors comparison functors@endlink.
577 template<>
578 struct less<void>
579 {
580 template <typename _Tp, typename _Up>
581 constexpr auto
582 operator()(_Tp&& __t, _Up&& __u) const
583 noexcept(noexcept(std::forward<_Tp>(__t) < std::forward<_Up>(__u)))
584 -> decltype(std::forward<_Tp>(__t) < std::forward<_Up>(__u))
585 {
586 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
587 __ptr_cmp<_Tp, _Up>{});
588 }
589
590 template<typename _Tp, typename _Up>
591 constexpr bool
592 operator()(_Tp* __t, _Up* __u) const noexcept
593 { return less<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
594
595 typedef __is_transparent is_transparent;
596
597 private:
598 template <typename _Tp, typename _Up>
599 static constexpr decltype(auto)
600 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
601 { return std::forward<_Tp>(__t) < std::forward<_Up>(__u); }
602
603 template <typename _Tp, typename _Up>
604 static constexpr bool
605 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
606 {
608 static_cast<const volatile void*>(std::forward<_Tp>(__t)),
609 static_cast<const volatile void*>(std::forward<_Up>(__u)));
610 }
611
612 // True if there is no viable operator< member function.
613 template<typename _Tp, typename _Up, typename = void>
614 struct __not_overloaded2 : true_type { };
615
616 // False if we can call T.operator<(U)
617 template<typename _Tp, typename _Up>
618 struct __not_overloaded2<_Tp, _Up, __void_t<
619 decltype(std::declval<_Tp>().operator<(std::declval<_Up>()))>>
620 : false_type { };
621
622 // True if there is no overloaded operator< for these operands.
623 template<typename _Tp, typename _Up, typename = void>
624 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
625
626 // False if we can call operator<(T,U)
627 template<typename _Tp, typename _Up>
628 struct __not_overloaded<_Tp, _Up, __void_t<
629 decltype(operator<(std::declval<_Tp>(), std::declval<_Up>()))>>
630 : false_type { };
631
632 template<typename _Tp, typename _Up>
633 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
636 };
637
638 /// One of the @link comparison_functors comparison functors@endlink.
639 template<>
640 struct greater_equal<void>
641 {
642 template <typename _Tp, typename _Up>
643 constexpr auto
644 operator()(_Tp&& __t, _Up&& __u) const
645 noexcept(noexcept(std::forward<_Tp>(__t) >= std::forward<_Up>(__u)))
646 -> decltype(std::forward<_Tp>(__t) >= std::forward<_Up>(__u))
647 {
648 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
649 __ptr_cmp<_Tp, _Up>{});
650 }
651
652 template<typename _Tp, typename _Up>
653 constexpr bool
654 operator()(_Tp* __t, _Up* __u) const noexcept
655 { return greater_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
656
657 typedef __is_transparent is_transparent;
658
659 private:
660 template <typename _Tp, typename _Up>
661 static constexpr decltype(auto)
662 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
663 { return std::forward<_Tp>(__t) >= std::forward<_Up>(__u); }
664
665 template <typename _Tp, typename _Up>
666 static constexpr bool
667 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
668 {
670 static_cast<const volatile void*>(std::forward<_Tp>(__t)),
671 static_cast<const volatile void*>(std::forward<_Up>(__u)));
672 }
673
674 // True if there is no viable operator>= member function.
675 template<typename _Tp, typename _Up, typename = void>
676 struct __not_overloaded2 : true_type { };
677
678 // False if we can call T.operator>=(U)
679 template<typename _Tp, typename _Up>
680 struct __not_overloaded2<_Tp, _Up, __void_t<
681 decltype(std::declval<_Tp>().operator>=(std::declval<_Up>()))>>
682 : false_type { };
683
684 // True if there is no overloaded operator>= for these operands.
685 template<typename _Tp, typename _Up, typename = void>
686 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
687
688 // False if we can call operator>=(T,U)
689 template<typename _Tp, typename _Up>
690 struct __not_overloaded<_Tp, _Up, __void_t<
691 decltype(operator>=(std::declval<_Tp>(), std::declval<_Up>()))>>
692 : false_type { };
693
694 template<typename _Tp, typename _Up>
695 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
698 };
699
700 /// One of the @link comparison_functors comparison functors@endlink.
701 template<>
702 struct less_equal<void>
703 {
704 template <typename _Tp, typename _Up>
705 constexpr auto
706 operator()(_Tp&& __t, _Up&& __u) const
707 noexcept(noexcept(std::forward<_Tp>(__t) <= std::forward<_Up>(__u)))
708 -> decltype(std::forward<_Tp>(__t) <= std::forward<_Up>(__u))
709 {
710 return _S_cmp(std::forward<_Tp>(__t), std::forward<_Up>(__u),
711 __ptr_cmp<_Tp, _Up>{});
712 }
713
714 template<typename _Tp, typename _Up>
715 constexpr bool
716 operator()(_Tp* __t, _Up* __u) const noexcept
717 { return less_equal<common_type_t<_Tp*, _Up*>>{}(__t, __u); }
718
719 typedef __is_transparent is_transparent;
720
721 private:
722 template <typename _Tp, typename _Up>
723 static constexpr decltype(auto)
724 _S_cmp(_Tp&& __t, _Up&& __u, false_type)
725 { return std::forward<_Tp>(__t) <= std::forward<_Up>(__u); }
726
727 template <typename _Tp, typename _Up>
728 static constexpr bool
729 _S_cmp(_Tp&& __t, _Up&& __u, true_type) noexcept
730 {
732 static_cast<const volatile void*>(std::forward<_Tp>(__t)),
733 static_cast<const volatile void*>(std::forward<_Up>(__u)));
734 }
735
736 // True if there is no viable operator<= member function.
737 template<typename _Tp, typename _Up, typename = void>
738 struct __not_overloaded2 : true_type { };
739
740 // False if we can call T.operator<=(U)
741 template<typename _Tp, typename _Up>
742 struct __not_overloaded2<_Tp, _Up, __void_t<
743 decltype(std::declval<_Tp>().operator<=(std::declval<_Up>()))>>
744 : false_type { };
745
746 // True if there is no overloaded operator<= for these operands.
747 template<typename _Tp, typename _Up, typename = void>
748 struct __not_overloaded : __not_overloaded2<_Tp, _Up> { };
749
750 // False if we can call operator<=(T,U)
751 template<typename _Tp, typename _Up>
752 struct __not_overloaded<_Tp, _Up, __void_t<
753 decltype(operator<=(std::declval<_Tp>(), std::declval<_Up>()))>>
754 : false_type { };
755
756 template<typename _Tp, typename _Up>
757 using __ptr_cmp = __and_<__not_overloaded<_Tp, _Up>,
760 };
761#endif // C++14
762 /** @} */
763
764 // 20.3.4 logical operations
765 /** @defgroup logical_functors Boolean Operations Classes
766 * @ingroup functors
767 *
768 * Here are wrapper functors for Boolean operations: @c &&, @c ||,
769 * and @c !.
770 *
771 * @{
772 */
773#if __cplusplus > 201103L
774 template<typename _Tp = void>
775 struct logical_and;
776
777 template<typename _Tp = void>
778 struct logical_or;
779
780 template<typename _Tp = void>
781 struct logical_not;
782#endif
783
784 /// One of the @link logical_functors Boolean operations functors@endlink.
785 template<typename _Tp>
786 struct logical_and : public binary_function<_Tp, _Tp, bool>
787 {
788 _GLIBCXX14_CONSTEXPR
789 bool
790 operator()(const _Tp& __x, const _Tp& __y) const
791 { return __x && __y; }
792 };
793
794 /// One of the @link logical_functors Boolean operations functors@endlink.
795 template<typename _Tp>
796 struct logical_or : public binary_function<_Tp, _Tp, bool>
797 {
798 _GLIBCXX14_CONSTEXPR
799 bool
800 operator()(const _Tp& __x, const _Tp& __y) const
801 { return __x || __y; }
802 };
803
804 /// One of the @link logical_functors Boolean operations functors@endlink.
805 template<typename _Tp>
806 struct logical_not : public unary_function<_Tp, bool>
807 {
808 _GLIBCXX14_CONSTEXPR
809 bool
810 operator()(const _Tp& __x) const
811 { return !__x; }
812 };
813
814#if __cplusplus > 201103L
815 /// One of the @link logical_functors Boolean operations functors@endlink.
816 template<>
817 struct logical_and<void>
818 {
819 template <typename _Tp, typename _Up>
820 _GLIBCXX14_CONSTEXPR
821 auto
822 operator()(_Tp&& __t, _Up&& __u) const
823 noexcept(noexcept(std::forward<_Tp>(__t) && std::forward<_Up>(__u)))
824 -> decltype(std::forward<_Tp>(__t) && std::forward<_Up>(__u))
825 { return std::forward<_Tp>(__t) && std::forward<_Up>(__u); }
826
827 typedef __is_transparent is_transparent;
828 };
829
830 /// One of the @link logical_functors Boolean operations functors@endlink.
831 template<>
832 struct logical_or<void>
833 {
834 template <typename _Tp, typename _Up>
835 _GLIBCXX14_CONSTEXPR
836 auto
837 operator()(_Tp&& __t, _Up&& __u) const
838 noexcept(noexcept(std::forward<_Tp>(__t) || std::forward<_Up>(__u)))
839 -> decltype(std::forward<_Tp>(__t) || std::forward<_Up>(__u))
840 { return std::forward<_Tp>(__t) || std::forward<_Up>(__u); }
841
842 typedef __is_transparent is_transparent;
843 };
844
845 /// One of the @link logical_functors Boolean operations functors@endlink.
846 template<>
847 struct logical_not<void>
848 {
849 template <typename _Tp>
850 _GLIBCXX14_CONSTEXPR
851 auto
852 operator()(_Tp&& __t) const
853 noexcept(noexcept(!std::forward<_Tp>(__t)))
854 -> decltype(!std::forward<_Tp>(__t))
855 { return !std::forward<_Tp>(__t); }
856
857 typedef __is_transparent is_transparent;
858 };
859#endif
860 /** @} */
861
862#if __cplusplus > 201103L
863 template<typename _Tp = void>
864 struct bit_and;
865
866 template<typename _Tp = void>
867 struct bit_or;
868
869 template<typename _Tp = void>
870 struct bit_xor;
871
872 template<typename _Tp = void>
873 struct bit_not;
874#endif
875
876 // _GLIBCXX_RESOLVE_LIB_DEFECTS
877 // DR 660. Missing Bitwise Operations.
878 template<typename _Tp>
879 struct bit_and : public binary_function<_Tp, _Tp, _Tp>
880 {
881 _GLIBCXX14_CONSTEXPR
882 _Tp
883 operator()(const _Tp& __x, const _Tp& __y) const
884 { return __x & __y; }
885 };
886
887 template<typename _Tp>
888 struct bit_or : public binary_function<_Tp, _Tp, _Tp>
889 {
890 _GLIBCXX14_CONSTEXPR
891 _Tp
892 operator()(const _Tp& __x, const _Tp& __y) const
893 { return __x | __y; }
894 };
895
896 template<typename _Tp>
897 struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
898 {
899 _GLIBCXX14_CONSTEXPR
900 _Tp
901 operator()(const _Tp& __x, const _Tp& __y) const
902 { return __x ^ __y; }
903 };
904
905 template<typename _Tp>
906 struct bit_not : public unary_function<_Tp, _Tp>
907 {
908 _GLIBCXX14_CONSTEXPR
909 _Tp
910 operator()(const _Tp& __x) const
911 { return ~__x; }
912 };
913
914#if __cplusplus > 201103L
915 template <>
916 struct bit_and<void>
917 {
918 template <typename _Tp, typename _Up>
919 _GLIBCXX14_CONSTEXPR
920 auto
921 operator()(_Tp&& __t, _Up&& __u) const
922 noexcept(noexcept(std::forward<_Tp>(__t) & std::forward<_Up>(__u)))
923 -> decltype(std::forward<_Tp>(__t) & std::forward<_Up>(__u))
924 { return std::forward<_Tp>(__t) & std::forward<_Up>(__u); }
925
926 typedef __is_transparent is_transparent;
927 };
928
929 template <>
930 struct bit_or<void>
931 {
932 template <typename _Tp, typename _Up>
933 _GLIBCXX14_CONSTEXPR
934 auto
935 operator()(_Tp&& __t, _Up&& __u) const
936 noexcept(noexcept(std::forward<_Tp>(__t) | std::forward<_Up>(__u)))
937 -> decltype(std::forward<_Tp>(__t) | std::forward<_Up>(__u))
938 { return std::forward<_Tp>(__t) | std::forward<_Up>(__u); }
939
940 typedef __is_transparent is_transparent;
941 };
942
943 template <>
944 struct bit_xor<void>
945 {
946 template <typename _Tp, typename _Up>
947 _GLIBCXX14_CONSTEXPR
948 auto
949 operator()(_Tp&& __t, _Up&& __u) const
950 noexcept(noexcept(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u)))
951 -> decltype(std::forward<_Tp>(__t) ^ std::forward<_Up>(__u))
952 { return std::forward<_Tp>(__t) ^ std::forward<_Up>(__u); }
953
954 typedef __is_transparent is_transparent;
955 };
956
957 template <>
958 struct bit_not<void>
959 {
960 template <typename _Tp>
961 _GLIBCXX14_CONSTEXPR
962 auto
963 operator()(_Tp&& __t) const
964 noexcept(noexcept(~std::forward<_Tp>(__t)))
965 -> decltype(~std::forward<_Tp>(__t))
966 { return ~std::forward<_Tp>(__t); }
967
968 typedef __is_transparent is_transparent;
969 };
970#endif
971
972 // 20.3.5 negators
973 /** @defgroup negators Negators
974 * @ingroup functors
975 *
976 * The functions @c not1 and @c not2 each take a predicate functor
977 * and return an instance of @c unary_negate or
978 * @c binary_negate, respectively. These classes are functors whose
979 * @c operator() performs the stored predicate function and then returns
980 * the negation of the result.
981 *
982 * For example, given a vector of integers and a trivial predicate,
983 * \code
984 * struct IntGreaterThanThree
985 * : public std::unary_function<int, bool>
986 * {
987 * bool operator() (int x) { return x > 3; }
988 * };
989 *
990 * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
991 * \endcode
992 * The call to @c find_if will locate the first index (i) of @c v for which
993 * <code>!(v[i] > 3)</code> is true.
994 *
995 * The not1/unary_negate combination works on predicates taking a single
996 * argument. The not2/binary_negate combination works on predicates which
997 * take two arguments.
998 *
999 * @{
1000 */
1001 /// One of the @link negators negation functors@endlink.
1002 template<typename _Predicate>
1004 : public unary_function<typename _Predicate::argument_type, bool>
1005 {
1006 protected:
1007 _Predicate _M_pred;
1008
1009 public:
1010 _GLIBCXX14_CONSTEXPR
1011 explicit
1012 unary_negate(const _Predicate& __x) : _M_pred(__x) { }
1013
1014 _GLIBCXX14_CONSTEXPR
1015 bool
1016 operator()(const typename _Predicate::argument_type& __x) const
1017 { return !_M_pred(__x); }
1018 };
1019
1020 /// One of the @link negators negation functors@endlink.
1021 template<typename _Predicate>
1022 _GLIBCXX14_CONSTEXPR
1024 not1(const _Predicate& __pred)
1025 { return unary_negate<_Predicate>(__pred); }
1026
1027 /// One of the @link negators negation functors@endlink.
1028 template<typename _Predicate>
1030 : public binary_function<typename _Predicate::first_argument_type,
1031 typename _Predicate::second_argument_type, bool>
1032 {
1033 protected:
1034 _Predicate _M_pred;
1035
1036 public:
1037 _GLIBCXX14_CONSTEXPR
1038 explicit
1039 binary_negate(const _Predicate& __x) : _M_pred(__x) { }
1040
1041 _GLIBCXX14_CONSTEXPR
1042 bool
1043 operator()(const typename _Predicate::first_argument_type& __x,
1044 const typename _Predicate::second_argument_type& __y) const
1045 { return !_M_pred(__x, __y); }
1046 };
1047
1048 /// One of the @link negators negation functors@endlink.
1049 template<typename _Predicate>
1050 _GLIBCXX14_CONSTEXPR
1052 not2(const _Predicate& __pred)
1053 { return binary_negate<_Predicate>(__pred); }
1054 /** @} */
1055
1056 // 20.3.7 adaptors pointers functions
1057 /** @defgroup pointer_adaptors Adaptors for pointers to functions
1058 * @ingroup functors
1059 *
1060 * The advantage of function objects over pointers to functions is that
1061 * the objects in the standard library declare nested typedefs describing
1062 * their argument and result types with uniform names (e.g., @c result_type
1063 * from the base classes @c unary_function and @c binary_function).
1064 * Sometimes those typedefs are required, not just optional.
1065 *
1066 * Adaptors are provided to turn pointers to unary (single-argument) and
1067 * binary (double-argument) functions into function objects. The
1068 * long-winded functor @c pointer_to_unary_function is constructed with a
1069 * function pointer @c f, and its @c operator() called with argument @c x
1070 * returns @c f(x). The functor @c pointer_to_binary_function does the same
1071 * thing, but with a double-argument @c f and @c operator().
1072 *
1073 * The function @c ptr_fun takes a pointer-to-function @c f and constructs
1074 * an instance of the appropriate functor.
1075 *
1076 * @{
1077 */
1078 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1079 template<typename _Arg, typename _Result>
1080 class pointer_to_unary_function : public unary_function<_Arg, _Result>
1081 {
1082 protected:
1083 _Result (*_M_ptr)(_Arg);
1084
1085 public:
1087
1088 explicit
1089 pointer_to_unary_function(_Result (*__x)(_Arg))
1090 : _M_ptr(__x) { }
1091
1092 _Result
1093 operator()(_Arg __x) const
1094 { return _M_ptr(__x); }
1095 };
1096
1097 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1098 template<typename _Arg, typename _Result>
1100 ptr_fun(_Result (*__x)(_Arg))
1102
1103 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1104 template<typename _Arg1, typename _Arg2, typename _Result>
1106 : public binary_function<_Arg1, _Arg2, _Result>
1107 {
1108 protected:
1109 _Result (*_M_ptr)(_Arg1, _Arg2);
1110
1111 public:
1113
1114 explicit
1115 pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
1116 : _M_ptr(__x) { }
1117
1118 _Result
1119 operator()(_Arg1 __x, _Arg2 __y) const
1120 { return _M_ptr(__x, __y); }
1121 };
1122
1123 /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
1124 template<typename _Arg1, typename _Arg2, typename _Result>
1126 ptr_fun(_Result (*__x)(_Arg1, _Arg2))
1128 /** @} */
1129
1130 template<typename _Tp>
1131 struct _Identity
1132 : public unary_function<_Tp, _Tp>
1133 {
1134 _Tp&
1135 operator()(_Tp& __x) const
1136 { return __x; }
1137
1138 const _Tp&
1139 operator()(const _Tp& __x) const
1140 { return __x; }
1141 };
1142
1143 // Partial specialization, avoids confusing errors in e.g. std::set<const T>.
1144 template<typename _Tp> struct _Identity<const _Tp> : _Identity<_Tp> { };
1145
1146 template<typename _Pair>
1147 struct _Select1st
1148 : public unary_function<_Pair, typename _Pair::first_type>
1149 {
1150 typename _Pair::first_type&
1151 operator()(_Pair& __x) const
1152 { return __x.first; }
1153
1154 const typename _Pair::first_type&
1155 operator()(const _Pair& __x) const
1156 { return __x.first; }
1157
1158#if __cplusplus >= 201103L
1159 template<typename _Pair2>
1160 typename _Pair2::first_type&
1161 operator()(_Pair2& __x) const
1162 { return __x.first; }
1163
1164 template<typename _Pair2>
1165 const typename _Pair2::first_type&
1166 operator()(const _Pair2& __x) const
1167 { return __x.first; }
1168#endif
1169 };
1170
1171 template<typename _Pair>
1172 struct _Select2nd
1173 : public unary_function<_Pair, typename _Pair::second_type>
1174 {
1175 typename _Pair::second_type&
1176 operator()(_Pair& __x) const
1177 { return __x.second; }
1178
1179 const typename _Pair::second_type&
1180 operator()(const _Pair& __x) const
1181 { return __x.second; }
1182 };
1183
1184 // 20.3.8 adaptors pointers members
1185 /** @defgroup memory_adaptors Adaptors for pointers to members
1186 * @ingroup functors
1187 *
1188 * There are a total of 8 = 2^3 function objects in this family.
1189 * (1) Member functions taking no arguments vs member functions taking
1190 * one argument.
1191 * (2) Call through pointer vs call through reference.
1192 * (3) Const vs non-const member function.
1193 *
1194 * All of this complexity is in the function objects themselves. You can
1195 * ignore it by using the helper function mem_fun and mem_fun_ref,
1196 * which create whichever type of adaptor is appropriate.
1197 *
1198 * @{
1199 */
1200 /// One of the @link memory_adaptors adaptors for member
1201 /// pointers@endlink.
1202 template<typename _Ret, typename _Tp>
1203 class mem_fun_t : public unary_function<_Tp*, _Ret>
1204 {
1205 public:
1206 explicit
1207 mem_fun_t(_Ret (_Tp::*__pf)())
1208 : _M_f(__pf) { }
1209
1210 _Ret
1211 operator()(_Tp* __p) const
1212 { return (__p->*_M_f)(); }
1213
1214 private:
1215 _Ret (_Tp::*_M_f)();
1216 };
1217
1218 /// One of the @link memory_adaptors adaptors for member
1219 /// pointers@endlink.
1220 template<typename _Ret, typename _Tp>
1221 class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
1222 {
1223 public:
1224 explicit
1225 const_mem_fun_t(_Ret (_Tp::*__pf)() const)
1226 : _M_f(__pf) { }
1227
1228 _Ret
1229 operator()(const _Tp* __p) const
1230 { return (__p->*_M_f)(); }
1231
1232 private:
1233 _Ret (_Tp::*_M_f)() const;
1234 };
1235
1236 /// One of the @link memory_adaptors adaptors for member
1237 /// pointers@endlink.
1238 template<typename _Ret, typename _Tp>
1239 class mem_fun_ref_t : public unary_function<_Tp, _Ret>
1240 {
1241 public:
1242 explicit
1243 mem_fun_ref_t(_Ret (_Tp::*__pf)())
1244 : _M_f(__pf) { }
1245
1246 _Ret
1247 operator()(_Tp& __r) const
1248 { return (__r.*_M_f)(); }
1249
1250 private:
1251 _Ret (_Tp::*_M_f)();
1252 };
1253
1254 /// One of the @link memory_adaptors adaptors for member
1255 /// pointers@endlink.
1256 template<typename _Ret, typename _Tp>
1257 class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
1258 {
1259 public:
1260 explicit
1261 const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
1262 : _M_f(__pf) { }
1263
1264 _Ret
1265 operator()(const _Tp& __r) const
1266 { return (__r.*_M_f)(); }
1267
1268 private:
1269 _Ret (_Tp::*_M_f)() const;
1270 };
1271
1272 /// One of the @link memory_adaptors adaptors for member
1273 /// pointers@endlink.
1274 template<typename _Ret, typename _Tp, typename _Arg>
1275 class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
1276 {
1277 public:
1278 explicit
1279 mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
1280 : _M_f(__pf) { }
1281
1282 _Ret
1283 operator()(_Tp* __p, _Arg __x) const
1284 { return (__p->*_M_f)(__x); }
1285
1286 private:
1287 _Ret (_Tp::*_M_f)(_Arg);
1288 };
1289
1290 /// One of the @link memory_adaptors adaptors for member
1291 /// pointers@endlink.
1292 template<typename _Ret, typename _Tp, typename _Arg>
1293 class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
1294 {
1295 public:
1296 explicit
1297 const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
1298 : _M_f(__pf) { }
1299
1300 _Ret
1301 operator()(const _Tp* __p, _Arg __x) const
1302 { return (__p->*_M_f)(__x); }
1303
1304 private:
1305 _Ret (_Tp::*_M_f)(_Arg) const;
1306 };
1307
1308 /// One of the @link memory_adaptors adaptors for member
1309 /// pointers@endlink.
1310 template<typename _Ret, typename _Tp, typename _Arg>
1311 class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1312 {
1313 public:
1314 explicit
1315 mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
1316 : _M_f(__pf) { }
1317
1318 _Ret
1319 operator()(_Tp& __r, _Arg __x) const
1320 { return (__r.*_M_f)(__x); }
1321
1322 private:
1323 _Ret (_Tp::*_M_f)(_Arg);
1324 };
1325
1326 /// One of the @link memory_adaptors adaptors for member
1327 /// pointers@endlink.
1328 template<typename _Ret, typename _Tp, typename _Arg>
1329 class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
1330 {
1331 public:
1332 explicit
1333 const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
1334 : _M_f(__pf) { }
1335
1336 _Ret
1337 operator()(const _Tp& __r, _Arg __x) const
1338 { return (__r.*_M_f)(__x); }
1339
1340 private:
1341 _Ret (_Tp::*_M_f)(_Arg) const;
1342 };
1343
1344 // Mem_fun adaptor helper functions. There are only two:
1345 // mem_fun and mem_fun_ref.
1346 template<typename _Ret, typename _Tp>
1348 mem_fun(_Ret (_Tp::*__f)())
1349 { return mem_fun_t<_Ret, _Tp>(__f); }
1350
1351 template<typename _Ret, typename _Tp>
1352 inline const_mem_fun_t<_Ret, _Tp>
1353 mem_fun(_Ret (_Tp::*__f)() const)
1354 { return const_mem_fun_t<_Ret, _Tp>(__f); }
1355
1356 template<typename _Ret, typename _Tp>
1357 inline mem_fun_ref_t<_Ret, _Tp>
1358 mem_fun_ref(_Ret (_Tp::*__f)())
1359 { return mem_fun_ref_t<_Ret, _Tp>(__f); }
1360
1361 template<typename _Ret, typename _Tp>
1362 inline const_mem_fun_ref_t<_Ret, _Tp>
1363 mem_fun_ref(_Ret (_Tp::*__f)() const)
1364 { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
1365
1366 template<typename _Ret, typename _Tp, typename _Arg>
1367 inline mem_fun1_t<_Ret, _Tp, _Arg>
1368 mem_fun(_Ret (_Tp::*__f)(_Arg))
1369 { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1370
1371 template<typename _Ret, typename _Tp, typename _Arg>
1372 inline const_mem_fun1_t<_Ret, _Tp, _Arg>
1373 mem_fun(_Ret (_Tp::*__f)(_Arg) const)
1374 { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
1375
1376 template<typename _Ret, typename _Tp, typename _Arg>
1377 inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
1378 mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
1379 { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1380
1381 template<typename _Ret, typename _Tp, typename _Arg>
1382 inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
1383 mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
1384 { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
1385
1386 /** @} */
1387
1388_GLIBCXX_END_NAMESPACE_VERSION
1389} // namespace
1390
1391#if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1392# include <backward/binders.h>
1393#endif
1394
1395#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:1330
_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:787
One of the Boolean operations functors.
Definition: stl_function.h:797
One of the Boolean operations functors.
Definition: stl_function.h:807
One of the negation functors.
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.