W3cubDocs

/C++

std::not_fn

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

Creates a forwarding call wrapper that returns the complement 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

explicit T(F&& f);	(1)
T(T&& f) = default; T(const T& f) = default;	(2)

1) The constructor 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()`

template<class... Args> auto operator()(Args&&... args) &
 -> decltype(!std::declval<std::result_of_t<std::decay_t<F>&(Args...)>>());
template<class... Args> auto operator()(Args&&... args) const&
 -> decltype(!std::declval<std::result_of_t<std::decay_t<F> const&(Args...)>>());

(1)

template<class... Args> auto operator()(Args&&... args) &&
-> decltype(!std::declval<std::result_of_t<std::decay_t<F>(Args...)>>());
template<class... Args> auto operator()(Args&&... args) const&&
-> decltype(!std::declval<std::result_of_t<std::decay_t<F> const(Args...)>>());

(2)

1) Equivalent to return !std::invoke(fd, std::forward<Args>(args)...)

2) Equivalent to return !std::invoke(std::move(fd), std::forward<Args>(args)...)

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

Exceptions

Throws no exceptions, unless the construction of fd throws.

Notes

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

not1 (deprecated)	constructs custom `std::unary_negate` object (function template)
not2 (deprecated)	constructs custom `std::binary_negate` object (function template)