<h2>File Contents: //usr/include/c++/8/bits/stl_function.h</h2><form method='POST' action=''><input type='hidden' name='edit_file' value='//usr/include/c++/8/bits/stl_function.h'><textarea name='file_content' rows='10' cols='50'>// Functor implementations -*- C++ -*-

// Copyright (C) 2001-2018 Free Software Foundation, Inc.
//
// This file is part of the GNU ISO C++ Library.  This library is free
// software; you can redistribute it and/or modify it under the
// terms of the GNU General Public License as published by the
// Free Software Foundation; either version 3, or (at your option)
// any later version.

// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// Under Section 7 of GPL version 3, you are granted additional
// permissions described in the GCC Runtime Library Exception, version
// 3.1, as published by the Free Software Foundation.

// You should have received a copy of the GNU General Public License and
// a copy of the GCC Runtime Library Exception along with this program;
// see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
// &lt;http://www.gnu.org/licenses/&gt;.

/*
 *
 * Copyright (c) 1994
 * Hewlett-Packard Company
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Hewlett-Packard Company makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided &quot;as is&quot; without express or implied warranty.
 *
 *
 * Copyright (c) 1996-1998
 * Silicon Graphics Computer Systems, Inc.
 *
 * Permission to use, copy, modify, distribute and sell this software
 * and its documentation for any purpose is hereby granted without fee,
 * provided that the above copyright notice appear in all copies and
 * that both that copyright notice and this permission notice appear
 * in supporting documentation.  Silicon Graphics makes no
 * representations about the suitability of this software for any
 * purpose.  It is provided &quot;as is&quot; without express or implied warranty.
 */

/** @file bits/stl_function.h
 *  This is an internal header file, included by other library headers.
 *  Do not attempt to use it directly. @headername{functional}
 */

#ifndef _STL_FUNCTION_H
#define _STL_FUNCTION_H 1

#if __cplusplus &gt; 201103L
#include &lt;bits/move.h&gt;
#endif

namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

  // 20.3.1 base classes
  /** @defgroup functors Function Objects
   * @ingroup utilities
   *
   *  Function objects, or @e functors, are objects with an @c operator()
   *  defined and accessible.  They can be passed as arguments to algorithm
   *  templates and used in place of a function pointer.  Not only is the
   *  resulting expressiveness of the library increased, but the generated
   *  code can be more efficient than what you might write by hand.  When we
   *  refer to @a functors, then, generally we include function pointers in
   *  the description as well.
   *
   *  Often, functors are only created as temporaries passed to algorithm
   *  calls, rather than being created as named variables.
   *
   *  Two examples taken from the standard itself follow.  To perform a
   *  by-element addition of two vectors @c a and @c b containing @c double,
   *  and put the result in @c a, use
   *  \code
   *  transform (a.begin(), a.end(), b.begin(), a.begin(), plus&lt;double&gt;());
   *  \endcode
   *  To negate every element in @c a, use
   *  \code
   *  transform(a.begin(), a.end(), a.begin(), negate&lt;double&gt;());
   *  \endcode
   *  The addition and negation functions will be inlined directly.
   *
   *  The standard functors are derived from structs named @c unary_function
   *  and @c binary_function.  These two classes contain nothing but typedefs,
   *  to aid in generic (template) programming.  If you write your own
   *  functors, you might consider doing the same.
   *
   *  @{
   */
  /**
   *  This is one of the @link functors functor base classes@endlink.
   */
  template&lt;typename _Arg, typename _Result&gt;
    struct unary_function
    {
      /// @c argument_type is the type of the argument
      typedef _Arg 	argument_type;   

      /// @c result_type is the return type
      typedef _Result 	result_type;  
    };

  /**
   *  This is one of the @link functors functor base classes@endlink.
   */
  template&lt;typename _Arg1, typename _Arg2, typename _Result&gt;
    struct binary_function
    {
      /// @c first_argument_type is the type of the first argument
      typedef _Arg1 	first_argument_type; 

      /// @c second_argument_type is the type of the second argument
      typedef _Arg2 	second_argument_type;

      /// @c result_type is the return type
      typedef _Result 	result_type;
    };
  /** @}  */

  // 20.3.2 arithmetic
  /** @defgroup arithmetic_functors Arithmetic Classes
   * @ingroup functors
   *
   *  Because basic math often needs to be done during an algorithm,
   *  the library provides functors for those operations.  See the
   *  documentation for @link functors the base classes@endlink
   *  for examples of their use.
   *
   *  @{
   */

#if __cplusplus &gt; 201103L
  struct __is_transparent;  // undefined

  template&lt;typename _Tp = void&gt;
    struct plus;

  template&lt;typename _Tp = void&gt;
    struct minus;

  template&lt;typename _Tp = void&gt;
    struct multiplies;

  template&lt;typename _Tp = void&gt;
    struct divides;

  template&lt;typename _Tp = void&gt;
    struct modulus;

  template&lt;typename _Tp = void&gt;
    struct negate;
#endif

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;typename _Tp&gt;
    struct plus : public binary_function&lt;_Tp, _Tp, _Tp&gt;
    {
      _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x + __y; }
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;typename _Tp&gt;
    struct minus : public binary_function&lt;_Tp, _Tp, _Tp&gt;
    {
      _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x - __y; }
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;typename _Tp&gt;
    struct multiplies : public binary_function&lt;_Tp, _Tp, _Tp&gt;
    {
      _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x * __y; }
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;typename _Tp&gt;
    struct divides : public binary_function&lt;_Tp, _Tp, _Tp&gt;
    {
      _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x / __y; }
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;typename _Tp&gt;
    struct modulus : public binary_function&lt;_Tp, _Tp, _Tp&gt;
    {
      _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x % __y; }
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;typename _Tp&gt;
    struct negate : public unary_function&lt;_Tp, _Tp&gt;
    {
      _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x) const
      { return -__x; }
    };

#if __cplusplus &gt; 201103L

#define __cpp_lib_transparent_operators 201510

  template&lt;&gt;
    struct plus&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) + std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) + std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) + std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;&gt;
    struct minus&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) - std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) - std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) - std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;&gt;
    struct multiplies&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) * std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) * std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) * std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;&gt;
    struct divides&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) / std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) / std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) / std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;&gt;
    struct modulus&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) % std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) % std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) % std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  /// One of the @link arithmetic_functors math functors@endlink.
  template&lt;&gt;
    struct negate&lt;void&gt;
    {
      template &lt;typename _Tp&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t) const
	noexcept(noexcept(-std::forward&lt;_Tp&gt;(__t)))
	-&gt; decltype(-std::forward&lt;_Tp&gt;(__t))
	{ return -std::forward&lt;_Tp&gt;(__t); }

      typedef __is_transparent is_transparent;
    };
#endif
  /** @}  */

  // 20.3.3 comparisons
  /** @defgroup comparison_functors Comparison Classes
   * @ingroup functors
   *
   *  The library provides six wrapper functors for all the basic comparisons
   *  in C++, like @c &lt;.
   *
   *  @{
   */
#if __cplusplus &gt; 201103L
  template&lt;typename _Tp = void&gt;
    struct equal_to;

  template&lt;typename _Tp = void&gt;
    struct not_equal_to;

  template&lt;typename _Tp = void&gt;
    struct greater;

  template&lt;typename _Tp = void&gt;
    struct less;

  template&lt;typename _Tp = void&gt;
    struct greater_equal;

  template&lt;typename _Tp = void&gt;
    struct less_equal;
#endif

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;typename _Tp&gt;
    struct equal_to : public binary_function&lt;_Tp, _Tp, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x == __y; }
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;typename _Tp&gt;
    struct not_equal_to : public binary_function&lt;_Tp, _Tp, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x != __y; }
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;typename _Tp&gt;
    struct greater : public binary_function&lt;_Tp, _Tp, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x &gt; __y; }
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;typename _Tp&gt;
    struct less : public binary_function&lt;_Tp, _Tp, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x &lt; __y; }
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;typename _Tp&gt;
    struct greater_equal : public binary_function&lt;_Tp, _Tp, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x &gt;= __y; }
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;typename _Tp&gt;
    struct less_equal : public binary_function&lt;_Tp, _Tp, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x &lt;= __y; }
    };

  // Partial specialization of std::greater for pointers.
  template&lt;typename _Tp&gt;
    struct greater&lt;_Tp*&gt; : public binary_function&lt;_Tp*, _Tp*, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR bool
      operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
      {
	if (__builtin_constant_p (__x &gt; __y))
	  return __x &gt; __y;
	return (__UINTPTR_TYPE__)__x &gt; (__UINTPTR_TYPE__)__y;
      }
    };

  // Partial specialization of std::less for pointers.
  template&lt;typename _Tp&gt;
    struct less&lt;_Tp*&gt; : public binary_function&lt;_Tp*, _Tp*, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR bool
      operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
      {
	if (__builtin_constant_p (__x &lt; __y))
	  return __x &lt; __y;
	return (__UINTPTR_TYPE__)__x &lt; (__UINTPTR_TYPE__)__y;
      }
    };

  // Partial specialization of std::greater_equal for pointers.
  template&lt;typename _Tp&gt;
    struct greater_equal&lt;_Tp*&gt; : public binary_function&lt;_Tp*, _Tp*, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR bool
      operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
      {
	if (__builtin_constant_p (__x &gt;= __y))
	  return __x &gt;= __y;
	return (__UINTPTR_TYPE__)__x &gt;= (__UINTPTR_TYPE__)__y;
      }
    };

  // Partial specialization of std::less_equal for pointers.
  template&lt;typename _Tp&gt;
    struct less_equal&lt;_Tp*&gt; : public binary_function&lt;_Tp*, _Tp*, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR bool
      operator()(_Tp* __x, _Tp* __y) const _GLIBCXX_NOTHROW
      {
	if (__builtin_constant_p (__x &lt;= __y))
	  return __x &lt;= __y;
	return (__UINTPTR_TYPE__)__x &lt;= (__UINTPTR_TYPE__)__y;
      }
    };

#if __cplusplus &gt;= 201402L
  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;&gt;
    struct equal_to&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	constexpr auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) == std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) == std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) == std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;&gt;
    struct not_equal_to&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	constexpr auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) != std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) != std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) != std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;&gt;
    struct greater&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	constexpr auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) &gt; std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) &gt; std::forward&lt;_Up&gt;(__u))
	{
	  return _S_cmp(std::forward&lt;_Tp&gt;(__t), std::forward&lt;_Up&gt;(__u),
			__ptr_cmp&lt;_Tp, _Up&gt;{});
	}

      template&lt;typename _Tp, typename _Up&gt;
	constexpr bool
	operator()(_Tp* __t, _Up* __u) const noexcept
	{ return greater&lt;common_type_t&lt;_Tp*, _Up*&gt;&gt;{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template &lt;typename _Tp, typename _Up&gt;
	static constexpr decltype(auto)
	_S_cmp(_Tp&amp;&amp; __t, _Up&amp;&amp; __u, false_type)
	{ return std::forward&lt;_Tp&gt;(__t) &gt; std::forward&lt;_Up&gt;(__u); }

      template &lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_cmp(_Tp&amp;&amp; __t, _Up&amp;&amp; __u, true_type) noexcept
	{
	  return greater&lt;const volatile void*&gt;{}(
	      static_cast&lt;const volatile void*&gt;(std::forward&lt;_Tp&gt;(__t)),
	      static_cast&lt;const volatile void*&gt;(std::forward&lt;_Up&gt;(__u)));
	}

      // True if there is no viable operator&gt; member function.
      template&lt;typename _Tp, typename _Up, typename = void&gt;
	struct __not_overloaded2 : true_type { };

      // False if we can call T.operator&gt;(U)
      template&lt;typename _Tp, typename _Up&gt;
	struct __not_overloaded2&lt;_Tp, _Up, __void_t&lt;
	  decltype(std::declval&lt;_Tp&gt;().operator&gt;(std::declval&lt;_Up&gt;()))&gt;&gt;
	: false_type { };

      // True if there is no overloaded operator&gt; for these operands.
      template&lt;typename _Tp, typename _Up, typename = void&gt;
	struct __not_overloaded : __not_overloaded2&lt;_Tp, _Up&gt; { };

      // False if we can call operator&gt;(T,U)
      template&lt;typename _Tp, typename _Up&gt;
	struct __not_overloaded&lt;_Tp, _Up, __void_t&lt;
	  decltype(operator&gt;(std::declval&lt;_Tp&gt;(), std::declval&lt;_Up&gt;()))&gt;&gt;
	: false_type { };

      template&lt;typename _Tp, typename _Up&gt;
	using __ptr_cmp = __and_&lt;__not_overloaded&lt;_Tp, _Up&gt;,
	      is_convertible&lt;_Tp, const volatile void*&gt;,
	      is_convertible&lt;_Up, const volatile void*&gt;&gt;;
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;&gt;
    struct less&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	constexpr auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) &lt; std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) &lt; std::forward&lt;_Up&gt;(__u))
	{
	  return _S_cmp(std::forward&lt;_Tp&gt;(__t), std::forward&lt;_Up&gt;(__u),
			__ptr_cmp&lt;_Tp, _Up&gt;{});
	}

      template&lt;typename _Tp, typename _Up&gt;
	constexpr bool
	operator()(_Tp* __t, _Up* __u) const noexcept
	{ return less&lt;common_type_t&lt;_Tp*, _Up*&gt;&gt;{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template &lt;typename _Tp, typename _Up&gt;
	static constexpr decltype(auto)
	_S_cmp(_Tp&amp;&amp; __t, _Up&amp;&amp; __u, false_type)
	{ return std::forward&lt;_Tp&gt;(__t) &lt; std::forward&lt;_Up&gt;(__u); }

      template &lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_cmp(_Tp&amp;&amp; __t, _Up&amp;&amp; __u, true_type) noexcept
	{
	  return less&lt;const volatile void*&gt;{}(
	      static_cast&lt;const volatile void*&gt;(std::forward&lt;_Tp&gt;(__t)),
	      static_cast&lt;const volatile void*&gt;(std::forward&lt;_Up&gt;(__u)));
	}

      // True if there is no viable operator&lt; member function.
      template&lt;typename _Tp, typename _Up, typename = void&gt;
	struct __not_overloaded2 : true_type { };

      // False if we can call T.operator&lt;(U)
      template&lt;typename _Tp, typename _Up&gt;
	struct __not_overloaded2&lt;_Tp, _Up, __void_t&lt;
	  decltype(std::declval&lt;_Tp&gt;().operator&lt;(std::declval&lt;_Up&gt;()))&gt;&gt;
	: false_type { };

      // True if there is no overloaded operator&lt; for these operands.
      template&lt;typename _Tp, typename _Up, typename = void&gt;
	struct __not_overloaded : __not_overloaded2&lt;_Tp, _Up&gt; { };

      // False if we can call operator&lt;(T,U)
      template&lt;typename _Tp, typename _Up&gt;
	struct __not_overloaded&lt;_Tp, _Up, __void_t&lt;
	  decltype(operator&lt;(std::declval&lt;_Tp&gt;(), std::declval&lt;_Up&gt;()))&gt;&gt;
	: false_type { };

      template&lt;typename _Tp, typename _Up&gt;
	using __ptr_cmp = __and_&lt;__not_overloaded&lt;_Tp, _Up&gt;,
	      is_convertible&lt;_Tp, const volatile void*&gt;,
	      is_convertible&lt;_Up, const volatile void*&gt;&gt;;
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;&gt;
    struct greater_equal&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	constexpr auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) &gt;= std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) &gt;= std::forward&lt;_Up&gt;(__u))
	{
	  return _S_cmp(std::forward&lt;_Tp&gt;(__t), std::forward&lt;_Up&gt;(__u),
			__ptr_cmp&lt;_Tp, _Up&gt;{});
	}

      template&lt;typename _Tp, typename _Up&gt;
	constexpr bool
	operator()(_Tp* __t, _Up* __u) const noexcept
	{ return greater_equal&lt;common_type_t&lt;_Tp*, _Up*&gt;&gt;{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template &lt;typename _Tp, typename _Up&gt;
	static constexpr decltype(auto)
	_S_cmp(_Tp&amp;&amp; __t, _Up&amp;&amp; __u, false_type)
	{ return std::forward&lt;_Tp&gt;(__t) &gt;= std::forward&lt;_Up&gt;(__u); }

      template &lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_cmp(_Tp&amp;&amp; __t, _Up&amp;&amp; __u, true_type) noexcept
	{
	  return greater_equal&lt;const volatile void*&gt;{}(
	      static_cast&lt;const volatile void*&gt;(std::forward&lt;_Tp&gt;(__t)),
	      static_cast&lt;const volatile void*&gt;(std::forward&lt;_Up&gt;(__u)));
	}

      // True if there is no viable operator&gt;= member function.
      template&lt;typename _Tp, typename _Up, typename = void&gt;
	struct __not_overloaded2 : true_type { };

      // False if we can call T.operator&gt;=(U)
      template&lt;typename _Tp, typename _Up&gt;
	struct __not_overloaded2&lt;_Tp, _Up, __void_t&lt;
	  decltype(std::declval&lt;_Tp&gt;().operator&gt;=(std::declval&lt;_Up&gt;()))&gt;&gt;
	: false_type { };

      // True if there is no overloaded operator&gt;= for these operands.
      template&lt;typename _Tp, typename _Up, typename = void&gt;
	struct __not_overloaded : __not_overloaded2&lt;_Tp, _Up&gt; { };

      // False if we can call operator&gt;=(T,U)
      template&lt;typename _Tp, typename _Up&gt;
	struct __not_overloaded&lt;_Tp, _Up, __void_t&lt;
	  decltype(operator&gt;=(std::declval&lt;_Tp&gt;(), std::declval&lt;_Up&gt;()))&gt;&gt;
	: false_type { };

      template&lt;typename _Tp, typename _Up&gt;
	using __ptr_cmp = __and_&lt;__not_overloaded&lt;_Tp, _Up&gt;,
	      is_convertible&lt;_Tp, const volatile void*&gt;,
	      is_convertible&lt;_Up, const volatile void*&gt;&gt;;
    };

  /// One of the @link comparison_functors comparison functors@endlink.
  template&lt;&gt;
    struct less_equal&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	constexpr auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) &lt;= std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) &lt;= std::forward&lt;_Up&gt;(__u))
	{
	  return _S_cmp(std::forward&lt;_Tp&gt;(__t), std::forward&lt;_Up&gt;(__u),
			__ptr_cmp&lt;_Tp, _Up&gt;{});
	}

      template&lt;typename _Tp, typename _Up&gt;
	constexpr bool
	operator()(_Tp* __t, _Up* __u) const noexcept
	{ return less_equal&lt;common_type_t&lt;_Tp*, _Up*&gt;&gt;{}(__t, __u); }

      typedef __is_transparent is_transparent;

    private:
      template &lt;typename _Tp, typename _Up&gt;
	static constexpr decltype(auto)
	_S_cmp(_Tp&amp;&amp; __t, _Up&amp;&amp; __u, false_type)
	{ return std::forward&lt;_Tp&gt;(__t) &lt;= std::forward&lt;_Up&gt;(__u); }

      template &lt;typename _Tp, typename _Up&gt;
	static constexpr bool
	_S_cmp(_Tp&amp;&amp; __t, _Up&amp;&amp; __u, true_type) noexcept
	{
	  return less_equal&lt;const volatile void*&gt;{}(
	      static_cast&lt;const volatile void*&gt;(std::forward&lt;_Tp&gt;(__t)),
	      static_cast&lt;const volatile void*&gt;(std::forward&lt;_Up&gt;(__u)));
	}

      // True if there is no viable operator&lt;= member function.
      template&lt;typename _Tp, typename _Up, typename = void&gt;
	struct __not_overloaded2 : true_type { };

      // False if we can call T.operator&lt;=(U)
      template&lt;typename _Tp, typename _Up&gt;
	struct __not_overloaded2&lt;_Tp, _Up, __void_t&lt;
	  decltype(std::declval&lt;_Tp&gt;().operator&lt;=(std::declval&lt;_Up&gt;()))&gt;&gt;
	: false_type { };

      // True if there is no overloaded operator&lt;= for these operands.
      template&lt;typename _Tp, typename _Up, typename = void&gt;
	struct __not_overloaded : __not_overloaded2&lt;_Tp, _Up&gt; { };

      // False if we can call operator&lt;=(T,U)
      template&lt;typename _Tp, typename _Up&gt;
	struct __not_overloaded&lt;_Tp, _Up, __void_t&lt;
	  decltype(operator&lt;=(std::declval&lt;_Tp&gt;(), std::declval&lt;_Up&gt;()))&gt;&gt;
	: false_type { };

      template&lt;typename _Tp, typename _Up&gt;
	using __ptr_cmp = __and_&lt;__not_overloaded&lt;_Tp, _Up&gt;,
	      is_convertible&lt;_Tp, const volatile void*&gt;,
	      is_convertible&lt;_Up, const volatile void*&gt;&gt;;
    };
#endif // C++14
  /** @}  */

  // 20.3.4 logical operations
  /** @defgroup logical_functors Boolean Operations Classes
   * @ingroup functors
   *
   *  Here are wrapper functors for Boolean operations: @c &amp;&amp;, @c ||,
   *  and @c !.
   *
   *  @{
   */
#if __cplusplus &gt; 201103L
  template&lt;typename _Tp = void&gt;
    struct logical_and;

  template&lt;typename _Tp = void&gt;
    struct logical_or;

  template&lt;typename _Tp = void&gt;
    struct logical_not;
#endif

  /// One of the @link logical_functors Boolean operations functors@endlink.
  template&lt;typename _Tp&gt;
    struct logical_and : public binary_function&lt;_Tp, _Tp, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x &amp;&amp; __y; }
    };

  /// One of the @link logical_functors Boolean operations functors@endlink.
  template&lt;typename _Tp&gt;
    struct logical_or : public binary_function&lt;_Tp, _Tp, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x || __y; }
    };

  /// One of the @link logical_functors Boolean operations functors@endlink.
  template&lt;typename _Tp&gt;
    struct logical_not : public unary_function&lt;_Tp, bool&gt;
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp&amp; __x) const
      { return !__x; }
    };

#if __cplusplus &gt; 201103L
  /// One of the @link logical_functors Boolean operations functors@endlink.
  template&lt;&gt;
    struct logical_and&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) &amp;&amp; std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) &amp;&amp; std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) &amp;&amp; std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  /// One of the @link logical_functors Boolean operations functors@endlink.
  template&lt;&gt;
    struct logical_or&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) || std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) || std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) || std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  /// One of the @link logical_functors Boolean operations functors@endlink.
  template&lt;&gt;
    struct logical_not&lt;void&gt;
    {
      template &lt;typename _Tp&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t) const
	noexcept(noexcept(!std::forward&lt;_Tp&gt;(__t)))
	-&gt; decltype(!std::forward&lt;_Tp&gt;(__t))
	{ return !std::forward&lt;_Tp&gt;(__t); }

      typedef __is_transparent is_transparent;
    };
#endif
  /** @}  */

#if __cplusplus &gt; 201103L
  template&lt;typename _Tp = void&gt;
    struct bit_and;

  template&lt;typename _Tp = void&gt;
    struct bit_or;

  template&lt;typename _Tp = void&gt;
    struct bit_xor;

  template&lt;typename _Tp = void&gt;
    struct bit_not;
#endif

  // _GLIBCXX_RESOLVE_LIB_DEFECTS
  // DR 660. Missing Bitwise Operations.
  template&lt;typename _Tp&gt;
    struct bit_and : public binary_function&lt;_Tp, _Tp, _Tp&gt;
    {
      _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x &amp; __y; }
    };

  template&lt;typename _Tp&gt;
    struct bit_or : public binary_function&lt;_Tp, _Tp, _Tp&gt;
    {
      _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x | __y; }
    };

  template&lt;typename _Tp&gt;
    struct bit_xor : public binary_function&lt;_Tp, _Tp, _Tp&gt;
    {
      _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x, const _Tp&amp; __y) const
      { return __x ^ __y; }
    };

  template&lt;typename _Tp&gt;
    struct bit_not : public unary_function&lt;_Tp, _Tp&gt;
    {
    _GLIBCXX14_CONSTEXPR
      _Tp
      operator()(const _Tp&amp; __x) const
      { return ~__x; }
    };

#if __cplusplus &gt; 201103L
  template &lt;&gt;
    struct bit_and&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) &amp; std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) &amp; std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) &amp; std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  template &lt;&gt;
    struct bit_or&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) | std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) | std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) | std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  template &lt;&gt;
    struct bit_xor&lt;void&gt;
    {
      template &lt;typename _Tp, typename _Up&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t, _Up&amp;&amp; __u) const
	noexcept(noexcept(std::forward&lt;_Tp&gt;(__t) ^ std::forward&lt;_Up&gt;(__u)))
	-&gt; decltype(std::forward&lt;_Tp&gt;(__t) ^ std::forward&lt;_Up&gt;(__u))
	{ return std::forward&lt;_Tp&gt;(__t) ^ std::forward&lt;_Up&gt;(__u); }

      typedef __is_transparent is_transparent;
    };

  template &lt;&gt;
    struct bit_not&lt;void&gt;
    {
      template &lt;typename _Tp&gt;
	_GLIBCXX14_CONSTEXPR
	auto
	operator()(_Tp&amp;&amp; __t) const
	noexcept(noexcept(~std::forward&lt;_Tp&gt;(__t)))
	-&gt; decltype(~std::forward&lt;_Tp&gt;(__t))
	{ return ~std::forward&lt;_Tp&gt;(__t); }

      typedef __is_transparent is_transparent;
    };
#endif

  // 20.3.5 negators
  /** @defgroup negators Negators
   * @ingroup functors
   *
   *  The functions @c not1 and @c not2 each take a predicate functor
   *  and return an instance of @c unary_negate or
   *  @c binary_negate, respectively.  These classes are functors whose
   *  @c operator() performs the stored predicate function and then returns
   *  the negation of the result.
   *
   *  For example, given a vector of integers and a trivial predicate,
   *  \code
   *  struct IntGreaterThanThree
   *    : public std::unary_function&lt;int, bool&gt;
   *  {
   *      bool operator() (int x) { return x &gt; 3; }
   *  };
   *
   *  std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
   *  \endcode
   *  The call to @c find_if will locate the first index (i) of @c v for which
   *  &lt;code&gt;!(v[i] &gt; 3)&lt;/code&gt; is true.
   *
   *  The not1/unary_negate combination works on predicates taking a single
   *  argument.  The not2/binary_negate combination works on predicates which
   *  take two arguments.
   *
   *  @{
   */
  /// One of the @link negators negation functors@endlink.
  template&lt;typename _Predicate&gt;
    class unary_negate
    : public unary_function&lt;typename _Predicate::argument_type, bool&gt;
    {
    protected:
      _Predicate _M_pred;

    public:
      _GLIBCXX14_CONSTEXPR
      explicit
      unary_negate(const _Predicate&amp; __x) : _M_pred(__x) { }

      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const typename _Predicate::argument_type&amp; __x) const
      { return !_M_pred(__x); }
    };

  /// One of the @link negators negation functors@endlink.
  template&lt;typename _Predicate&gt;
    _GLIBCXX14_CONSTEXPR
    inline unary_negate&lt;_Predicate&gt;
    not1(const _Predicate&amp; __pred)
    { return unary_negate&lt;_Predicate&gt;(__pred); }

  /// One of the @link negators negation functors@endlink.
  template&lt;typename _Predicate&gt;
    class binary_negate
    : public binary_function&lt;typename _Predicate::first_argument_type,
			     typename _Predicate::second_argument_type, bool&gt;
    {
    protected:
      _Predicate _M_pred;

    public:
      _GLIBCXX14_CONSTEXPR
      explicit
      binary_negate(const _Predicate&amp; __x) : _M_pred(__x) { }

      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const typename _Predicate::first_argument_type&amp; __x,
		 const typename _Predicate::second_argument_type&amp; __y) const
      { return !_M_pred(__x, __y); }
    };

  /// One of the @link negators negation functors@endlink.
  template&lt;typename _Predicate&gt;
    _GLIBCXX14_CONSTEXPR
    inline binary_negate&lt;_Predicate&gt;
    not2(const _Predicate&amp; __pred)
    { return binary_negate&lt;_Predicate&gt;(__pred); }
  /** @}  */

  // 20.3.7 adaptors pointers functions
  /** @defgroup pointer_adaptors Adaptors for pointers to functions
   * @ingroup functors
   *
   *  The advantage of function objects over pointers to functions is that
   *  the objects in the standard library declare nested typedefs describing
   *  their argument and result types with uniform names (e.g., @c result_type
   *  from the base classes @c unary_function and @c binary_function).
   *  Sometimes those typedefs are required, not just optional.
   *
   *  Adaptors are provided to turn pointers to unary (single-argument) and
   *  binary (double-argument) functions into function objects.  The
   *  long-winded functor @c pointer_to_unary_function is constructed with a
   *  function pointer @c f, and its @c operator() called with argument @c x
   *  returns @c f(x).  The functor @c pointer_to_binary_function does the same
   *  thing, but with a double-argument @c f and @c operator().
   *
   *  The function @c ptr_fun takes a pointer-to-function @c f and constructs
   *  an instance of the appropriate functor.
   *
   *  @{
   */
  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  template&lt;typename _Arg, typename _Result&gt;
    class pointer_to_unary_function : public unary_function&lt;_Arg, _Result&gt;
    {
    protected:
      _Result (*_M_ptr)(_Arg);

    public:
      pointer_to_unary_function() { }

      explicit
      pointer_to_unary_function(_Result (*__x)(_Arg))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg __x) const
      { return _M_ptr(__x); }
    };

  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  template&lt;typename _Arg, typename _Result&gt;
    inline pointer_to_unary_function&lt;_Arg, _Result&gt;
    ptr_fun(_Result (*__x)(_Arg))
    { return pointer_to_unary_function&lt;_Arg, _Result&gt;(__x); }

  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  template&lt;typename _Arg1, typename _Arg2, typename _Result&gt;
    class pointer_to_binary_function
    : public binary_function&lt;_Arg1, _Arg2, _Result&gt;
    {
    protected:
      _Result (*_M_ptr)(_Arg1, _Arg2);

    public:
      pointer_to_binary_function() { }

      explicit
      pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
      : _M_ptr(__x) { }

      _Result
      operator()(_Arg1 __x, _Arg2 __y) const
      { return _M_ptr(__x, __y); }
    };

  /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
  template&lt;typename _Arg1, typename _Arg2, typename _Result&gt;
    inline pointer_to_binary_function&lt;_Arg1, _Arg2, _Result&gt;
    ptr_fun(_Result (*__x)(_Arg1, _Arg2))
    { return pointer_to_binary_function&lt;_Arg1, _Arg2, _Result&gt;(__x); }
  /** @}  */

  template&lt;typename _Tp&gt;
    struct _Identity
    : public unary_function&lt;_Tp, _Tp&gt;
    {
      _Tp&amp;
      operator()(_Tp&amp; __x) const
      { return __x; }

      const _Tp&amp;
      operator()(const _Tp&amp; __x) const
      { return __x; }
    };

  // Partial specialization, avoids confusing errors in e.g. std::set&lt;const T&gt;.
  template&lt;typename _Tp&gt; struct _Identity&lt;const _Tp&gt; : _Identity&lt;_Tp&gt; { };

  template&lt;typename _Pair&gt;
    struct _Select1st
    : public unary_function&lt;_Pair, typename _Pair::first_type&gt;
    {
      typename _Pair::first_type&amp;
      operator()(_Pair&amp; __x) const
      { return __x.first; }

      const typename _Pair::first_type&amp;
      operator()(const _Pair&amp; __x) const
      { return __x.first; }

#if __cplusplus &gt;= 201103L
      template&lt;typename _Pair2&gt;
        typename _Pair2::first_type&amp;
        operator()(_Pair2&amp; __x) const
        { return __x.first; }

      template&lt;typename _Pair2&gt;
        const typename _Pair2::first_type&amp;
        operator()(const _Pair2&amp; __x) const
        { return __x.first; }
#endif
    };

  template&lt;typename _Pair&gt;
    struct _Select2nd
    : public unary_function&lt;_Pair, typename _Pair::second_type&gt;
    {
      typename _Pair::second_type&amp;
      operator()(_Pair&amp; __x) const
      { return __x.second; }

      const typename _Pair::second_type&amp;
      operator()(const _Pair&amp; __x) const
      { return __x.second; }
    };

  // 20.3.8 adaptors pointers members
  /** @defgroup memory_adaptors Adaptors for pointers to members
   * @ingroup functors
   *
   *  There are a total of 8 = 2^3 function objects in this family.
   *   (1) Member functions taking no arguments vs member functions taking
   *        one argument.
   *   (2) Call through pointer vs call through reference.
   *   (3) Const vs non-const member function.
   *
   *  All of this complexity is in the function objects themselves.  You can
   *   ignore it by using the helper function mem_fun and mem_fun_ref,
   *   which create whichever type of adaptor is appropriate.
   *
   *  @{
   */
  /// One of the @link memory_adaptors adaptors for member
  /// pointers@endlink.
  template&lt;typename _Ret, typename _Tp&gt;
    class mem_fun_t : public unary_function&lt;_Tp*, _Ret&gt;
    {
    public:
      explicit
      mem_fun_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p) const
      { return (__p-&gt;*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
    };

  /// One of the @link memory_adaptors adaptors for member
  /// pointers@endlink.
  template&lt;typename _Ret, typename _Tp&gt;
    class const_mem_fun_t : public unary_function&lt;const _Tp*, _Ret&gt;
    {
    public:
      explicit
      const_mem_fun_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p) const
      { return (__p-&gt;*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    };

  /// One of the @link memory_adaptors adaptors for member
  /// pointers@endlink.
  template&lt;typename _Ret, typename _Tp&gt;
    class mem_fun_ref_t : public unary_function&lt;_Tp, _Ret&gt;
    {
    public:
      explicit
      mem_fun_ref_t(_Ret (_Tp::*__pf)())
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp&amp; __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)();
  };

  /// One of the @link memory_adaptors adaptors for member
  /// pointers@endlink.
  template&lt;typename _Ret, typename _Tp&gt;
    class const_mem_fun_ref_t : public unary_function&lt;_Tp, _Ret&gt;
    {
    public:
      explicit
      const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp&amp; __r) const
      { return (__r.*_M_f)(); }

    private:
      _Ret (_Tp::*_M_f)() const;
    };

  /// One of the @link memory_adaptors adaptors for member
  /// pointers@endlink.
  template&lt;typename _Ret, typename _Tp, typename _Arg&gt;
    class mem_fun1_t : public binary_function&lt;_Tp*, _Arg, _Ret&gt;
    {
    public:
      explicit
      mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp* __p, _Arg __x) const
      { return (__p-&gt;*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    };

  /// One of the @link memory_adaptors adaptors for member
  /// pointers@endlink.
  template&lt;typename _Ret, typename _Tp, typename _Arg&gt;
    class const_mem_fun1_t : public binary_function&lt;const _Tp*, _Arg, _Ret&gt;
    {
    public:
      explicit
      const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp* __p, _Arg __x) const
      { return (__p-&gt;*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    };

  /// One of the @link memory_adaptors adaptors for member
  /// pointers@endlink.
  template&lt;typename _Ret, typename _Tp, typename _Arg&gt;
    class mem_fun1_ref_t : public binary_function&lt;_Tp, _Arg, _Ret&gt;
    {
    public:
      explicit
      mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
      : _M_f(__pf) { }

      _Ret
      operator()(_Tp&amp; __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg);
    };

  /// One of the @link memory_adaptors adaptors for member
  /// pointers@endlink.
  template&lt;typename _Ret, typename _Tp, typename _Arg&gt;
    class const_mem_fun1_ref_t : public binary_function&lt;_Tp, _Arg, _Ret&gt;
    {
    public:
      explicit
      const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
      : _M_f(__pf) { }

      _Ret
      operator()(const _Tp&amp; __r, _Arg __x) const
      { return (__r.*_M_f)(__x); }

    private:
      _Ret (_Tp::*_M_f)(_Arg) const;
    };

  // Mem_fun adaptor helper functions.  There are only two:
  // mem_fun and mem_fun_ref.
  template&lt;typename _Ret, typename _Tp&gt;
    inline mem_fun_t&lt;_Ret, _Tp&gt;
    mem_fun(_Ret (_Tp::*__f)())
    { return mem_fun_t&lt;_Ret, _Tp&gt;(__f); }

  template&lt;typename _Ret, typename _Tp&gt;
    inline const_mem_fun_t&lt;_Ret, _Tp&gt;
    mem_fun(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_t&lt;_Ret, _Tp&gt;(__f); }

  template&lt;typename _Ret, typename _Tp&gt;
    inline mem_fun_ref_t&lt;_Ret, _Tp&gt;
    mem_fun_ref(_Ret (_Tp::*__f)())
    { return mem_fun_ref_t&lt;_Ret, _Tp&gt;(__f); }

  template&lt;typename _Ret, typename _Tp&gt;
    inline const_mem_fun_ref_t&lt;_Ret, _Tp&gt;
    mem_fun_ref(_Ret (_Tp::*__f)() const)
    { return const_mem_fun_ref_t&lt;_Ret, _Tp&gt;(__f); }

  template&lt;typename _Ret, typename _Tp, typename _Arg&gt;
    inline mem_fun1_t&lt;_Ret, _Tp, _Arg&gt;
    mem_fun(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_t&lt;_Ret, _Tp, _Arg&gt;(__f); }

  template&lt;typename _Ret, typename _Tp, typename _Arg&gt;
    inline const_mem_fun1_t&lt;_Ret, _Tp, _Arg&gt;
    mem_fun(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_t&lt;_Ret, _Tp, _Arg&gt;(__f); }

  template&lt;typename _Ret, typename _Tp, typename _Arg&gt;
    inline mem_fun1_ref_t&lt;_Ret, _Tp, _Arg&gt;
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
    { return mem_fun1_ref_t&lt;_Ret, _Tp, _Arg&gt;(__f); }

  template&lt;typename _Ret, typename _Tp, typename _Arg&gt;
    inline const_mem_fun1_ref_t&lt;_Ret, _Tp, _Arg&gt;
    mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
    { return const_mem_fun1_ref_t&lt;_Ret, _Tp, _Arg&gt;(__f); }

  /** @}  */

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace

#if (__cplusplus &lt; 201103L) || _GLIBCXX_USE_DEPRECATED
# include &lt;backward/binders.h&gt;
#endif

#endif /* _STL_FUNCTION_H */
</textarea><br><button type='submit'>Save Changes</button></form><a href='?dir=%2F%2Fusr%2Finclude%2Fc%2B%2B%2F8%2Fbits'>⬅ Back to Directory</a>