std::not_fn
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) |
|
explicit constexpr 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>
Expression-equivalent
Expression e
is expression-equivalent to expression f
, if.
-
e
andf
have the same effects, and - either both are constant subexpressions or else neither is a constant subexpression, and
- either both are potentially-throwing or else neither is potentially-throwing (i.e.
noexcept(e) == noexcept(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
not_fn
is intended to replace the C++03-era negators std::not1
and std::not2
.
Feature testing macro: __cpp_lib_not_fn
.
Example
See also
(deprecated in C++17)(removed in C++20)
|
constructs custom std::unary_negate object (function template) |
(deprecated in C++17)(removed in C++20)
|
constructs custom std::binary_negate object (function template) |
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/utility/functional/not_fn