std::not_fn

Utilities library

Language support
Type support (basic types, RTTI)
Library feature-test macros (C++20)
Dynamic memory management
Program utilities
Coroutine support (C++20)
Variadic functions
is_constant_evaluated (C++20)
is_within_lifetime (C++26)
initializer_list (C++11)
source_location (C++20)
Three-way comparison (C++20)
three_way_comparablethree_way_comparable_with (C++20)(C++20)
strong_ordering (C++20)
weak_ordering (C++20)
partial_ordering (C++20)
common_comparison_category (C++20)
compare_three_way_result (C++20)
compare_three_way (C++20)
strong_order (C++20)
weak_order (C++20)
partial_order (C++20)
compare_strong_order_fallback (C++20)
compare_weak_order_fallback (C++20)
compare_partial_order_fallback (C++20)
is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

General utilities

Date and time

Function objects

Formatting library (C++20)

bitset

hash

(C++11)

Relational operators (deprecated in C++20)

rel_ops::operator!=rel_ops::operator>

rel_ops::operator<=rel_ops::operator>=

Integer comparison functions

cmp_equalcmp_lesscmp_less_than

(C++20)(C++20)(C++20)

cmp_not_equalcmp_greatercmp_greater_than

(C++20)(C++20)(C++20)

in_range

(C++20)

Swap and type operations

swap
ranges::swap (C++20)
exchange (C++14)
declval (C++11)
to_underlying (C++23)

forward (C++11)
forward_like (C++23)
move (C++11)
move_if_noexcept (C++11)
as_const (C++17)

Common vocabulary types

pair
tuple (C++11)
optional (C++17)
any (C++17)
variant (C++17)

tuple_size (C++11)
tuple_element (C++11)
apply (C++17)
make_from_tuple (C++17)
expected (C++23)

Elementary string conversions

(C++17)

(C++17)

(C++17)

Function wrappers
function (C++11)
move_only_function (C++23)
copyable_function (C++26)
function_ref (C++26)
mem_fn (C++11)
bad_function_call (C++11)

Partial function application
bind_frontbind_back (C++20)(C++23)
bind (C++11)
is_bind_expression (C++11)
is_placeholder (C++11)
_1, _2, _3, ... (C++11)

Function invocation
invokeinvoke_r (C++17)(C++23)
Identity function object
identity (C++20)

Reference wrappers
reference_wrapper (C++11)
refcref (C++11)(C++11)
unwrap_referenceunwrap_ref_decay (C++20)(C++20)

Operator wrappers

plus
minus
negate
multiplies
divides
modulus
bit_and
bit_or
bit_not (C++14)
bit_xor

equal_to
not_equal_to
greater
less
greater_equal
less_equal
logical_and
logical_or
logical_not

Transparent operator wrappers

plus<> (C++14)
minus<> (C++14)
negate<> (C++14)
multiplies<> (C++14)
divides<> (C++14)
modulus<> (C++14)
bit_and<> (C++14)
bit_or<> (C++14)
bit_not<> (C++14)
bit_xor<> (C++14)

equal_to<> (C++14)
not_equal_to<> (C++14)
greater<> (C++14)
less<> (C++14)
greater_equal<> (C++14)
less_equal<> (C++14)
logical_and<> (C++14)
logical_or<> (C++14)
logical_not<> (C++14)

Negators
not_fn (C++17)
Searchers
default_searcher (C++17)
boyer_moore_searcher (C++17)
boyer_moore_horspool_searcher (C++17)

Constrained comparators
ranges::equal_to (C++20)
ranges::not_equal_to (C++20)
ranges::greater (C++20)
ranges::less (C++20)
ranges::greater_equal (C++20)
ranges::less_equal (C++20)
compare_three_way (C++20)

Old binders and adaptors

unary_function (until C++17*)
binary_function (until C++17*)
ptr_fun (until C++17*)
pointer_to_unary_function (until C++17*)
pointer_to_binary_function (until C++17*)
mem_fun (until C++17*)
mem_fun_tmem_fun1_tconst_mem_fun_tconst_mem_fun1_t (until C++17)(until C++17)(until C++17)(until C++17)
not1 (until C++20*)
not2 (until C++20*)

binder1stbinder2nd (until C++17)(until C++17)
bind1stbind2nd (until C++17)(until C++17)

mem_fun_ref (until C++17*)
mem_fun_ref_tmem_fun1_ref_tconst_mem_fun_ref_tconst_mem_fun1_ref_t (until C++17)(until C++17)(until C++17)(until C++17)
unary_negate (until C++20*)
binary_negate (until C++20*)

Defined in header `<functional>`
template< class F > /* unspecified */ not_fn( F&& f );		(since C++17) (until C++20)
template< class F > constexpr /* unspecified */ not_fn( F&& f );		(since C++20)

Creates a forwarding call wrapper that returns the negation of the callable object it holds.

Parameters

f	-	the object from which the Callable object held by the wrapper is constructed
Type requirements
- `std::decay_t<F>` must meet the requirements of Callable and MoveConstructible.
- std::is_constructible_v<std::decay_t<F>, F> is required to be true

Return value

A function object of unspecified type T. It has the following members:

std::not_fn return type

Member objects

The return type of std::not_fn holds a member object of type std::decay_t<F>.

Constructors

	(1)
explicit T(F&& f); // exposition only			(since C++17) (until C++20)
constexpr explicit T(F&& f); // exposition only			(since C++20)
T(T&& f) = default; T(const T& f) = default;		(2)

1) The constructor direct-non-list-initializes the member object (of type std::decay_t<F>) from std::forward<F>(f). Throws any exception thrown by the constructor selected.

2) Because std::decay_t<F> is required to be MoveConstructible, the returned call wrapper is always MoveConstructible, and is CopyConstructible if std::decay_t<F> is CopyConstructible.

Member function operator()

	(1)
template< class... Args > auto operator()( Args&&... args ) & -> decltype(!std::declval< std::invoke_result_t<std::decay_t<F>&, Args...>>()); template< class... Args > auto operator()( Args&&... args ) const& -> decltype(!std::declval< std::invoke_result_t<std::decay_t<F> const&, Args...>>());			(since C++17) (until C++20)
template< class... Args > constexpr auto operator()( Args&&... args ) & noexcept(/* see below /) -> decltype(!std::declval< std::invoke_result_t<std::decay_t<F>&, Args...>>()); template< class... Args > constexpr auto operator()( Args&&... args ) const& noexcept(/ see below */) -> decltype(!std::declval< std::invoke_result_t<std::decay_t<F> const&, Args...>>());			(since C++20)
		(2)
template< class... Args > auto operator()( Args&&... args ) && -> decltype(!std::declval< std::invoke_result_t<std::decay_t<F>, Args...>>()); template< class... Args > auto operator()( Args&&... args ) const&& -> decltype(!std::declval< std::invoke_result_t<std::decay_t<F> const, Args...>>());				(since C++17) (until C++20)
template< class... Args > constexpr auto operator()( Args&&... args ) && noexcept(/* see below /) -> decltype(!std::declval< std::invoke_result_t<std::decay_t<F>, Args...>>()); template< class... Args > constexpr auto operator()( Args&&... args ) const&& noexcept(/ see below */) -> decltype(!std::declval< std::invoke_result_t<std::decay_t<F> const, Args...>>());				(since C++20)

1) Equivalent to return !std::invoke(fd, std::forward<Args>(args)...); 2) Equivalent to return !std::invoke(std::move(fd), std::forward<Args>(args)...);	(since C++17) (until C++20)
1) Expression-equivalent to !std::invoke(fd, std::forward<Args>(args)...) 2) Expression-equivalent to !std::invoke(std::move(fd), std::forward<Args>(args)...)	(since C++20)

where fd is the member object of type std::decay_t<F>.

Exceptions

Throws no exceptions, unless the construction of fd throws.

Possible implementation

namespace detail
{
    template<class F>
    struct not_fn_t
    {
        F f;
 
        template<class... Args>
        constexpr auto operator()(Args&&... args) &
            noexcept(noexcept(!std::invoke(f, std::forward<Args>(args)...)))
            -> decltype(!std::invoke(f, std::forward<Args>(args)...))
        {
            return !std::invoke(f, std::forward<Args>(args)...);
        }
 
        template<class... Args>
        constexpr auto operator()(Args&&... args) const&
            noexcept(noexcept(!std::invoke(f, std::forward<Args>(args)...)))
            -> decltype(!std::invoke(f, std::forward<Args>(args)...))
        {
            return !std::invoke(f, std::forward<Args>(args)...);
        }
 
        template<class... Args>
        constexpr auto operator()(Args&&... args) &&
            noexcept(noexcept(!std::invoke(std::move(f), std::forward<Args>(args)...)))
            -> decltype(!std::invoke(std::move(f), std::forward<Args>(args)...))
        {
            return !std::invoke(std::move(f), std::forward<Args>(args)...);
        }
 
        template<class... Args>
        constexpr auto operator()(Args&&... args) const&&
            noexcept(noexcept(!std::invoke(std::move(f), std::forward<Args>(args)...)))
            -> decltype(!std::invoke(std::move(f), std::forward<Args>(args)...))
        {
            return !std::invoke(std::move(f), std::forward<Args>(args)...);
        }
    };
}
 
template<class F>
constexpr detail::not_fn_t<std::decay_t<F>> not_fn(F&& f)
{
    return {std::forward<F>(f)};
}

Notes

std::not_fn is intended to replace the C++03-era negators std::not1 and std::not2.

Feature-test macro	Value	Std	Comment
`__cpp_lib_not_fn`	201603L	(C++17)	`std::not_fn()`

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Metaprogramming library (C++11)
Diagnostics library
General utilities library
Strings library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Numerics library
Localizations library
Input/output library
Filesystem library (C++17)
Regular expressions library (C++11)
Concurrency support library (C++11)
Technical specifications
Symbols index
External libraries

not1 (deprecated in C++17)(removed in C++20)	constructs custom std::unary_negate object (function template)
not2 (deprecated in C++17)(removed in C++20)	constructs custom std::binary_negate object (function template)

std::not_fn

Parameters

Return value

std::not_fn return type

Member objects

Constructors

Member function operator()

Exceptions

Possible implementation

Notes

Example

See also

Navigation