# std::not_fn

From cppreference.com
< cpp‎ | utility‎ | functional

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()`

### Example

| This section is incomplete Reason: no example

### See also

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)

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/not_fn&oldid=154482"