Difference between revisions of "cpp/utility/functional/not fn"
From cppreference.com
< cpp | utility | functional
m (→Possible implementation: The deleted overloads are made needed per P0356R5.) |
(Oh, use of invoke_result_t is incorrect since C++20 (but was exactly specified in C++17).) |
||
| (3 intermediate revisions by one user not shown) | |||
| Line 42: | Line 42: | ||
@1@ The constructor direct-non-list-initializes the member object (of type {{c/core|std::decay_t<F>}}) from {{c|std::forward<F>(f)}}. Throws any exception thrown by the constructor selected. | @1@ The constructor direct-non-list-initializes the member object (of type {{c/core|std::decay_t<F>}}) from {{c|std::forward<F>(f)}}. Throws any exception thrown by the constructor selected. | ||
@2@ Because {{c/core|std::decay_t<F>}} is required to be {{named req|MoveConstructible}}, the returned call wrapper is always {{named req|MoveConstructible}}, and is {{named req|CopyConstructible}} if {{c/core|std::decay_t<F>}} is {{named req|CopyConstructible}}. | @2@ Because {{c/core|std::decay_t<F>}} is required to be {{named req|MoveConstructible}}, the returned call wrapper is always {{named req|MoveConstructible}}, and is {{named req|CopyConstructible}} if {{c/core|std::decay_t<F>}} is {{named req|CopyConstructible}}. | ||
| − | + | {{rrev multi|rev1= | |
| − | It is unspecified whether the return type is assignable. | + | The explicitly defaulted definitions make the return type not assignable. |
| + | |since2=c++20|rev2= | ||
| + | It is unspecified whether these constructors are explicitly defaulted and whether the return type is assignable. | ||
| + | }} | ||
====Member function {{c/core|operator()}}==== | ====Member function {{c/core|operator()}}==== | ||
| Line 60: | Line 63: | ||
constexpr auto operator()( Args&&... args ) & | constexpr auto operator()( Args&&... args ) & | ||
noexcept(/* see below */) | noexcept(/* see below */) | ||
| − | -> decltype(!std:: | + | -> decltype(!std::invoke( |
| − | std:: | + | std::declval<std::decay_t<F>&>(), std::declval<Args>()...)); |
template< class... Args > | template< class... Args > | ||
constexpr auto operator()( Args&&... args ) const& | constexpr auto operator()( Args&&... args ) const& | ||
noexcept(/* see below */) | noexcept(/* see below */) | ||
| − | -> decltype(!std:: | + | -> decltype(!std::invoke( |
| − | std:: | + | std::declval<std::decay_t<F> const&>(), std::declval<Args>()...)); |
}} | }} | ||
{{dcl rev multi|num=2|since1=c++17|dcl1= | {{dcl rev multi|num=2|since1=c++17|dcl1= | ||
| Line 81: | Line 84: | ||
constexpr auto operator()( Args&&... args ) && | constexpr auto operator()( Args&&... args ) && | ||
noexcept(/* see below */) | noexcept(/* see below */) | ||
| − | -> decltype(!std:: | + | -> decltype(!std::invoke( |
| − | std:: | + | std::declval<std::decay_t<F>>(), std::declval<Args>()...)); |
template< class... Args > | template< class... Args > | ||
constexpr auto operator()( Args&&... args ) const&& | constexpr auto operator()( Args&&... args ) const&& | ||
noexcept(/* see below */) | noexcept(/* see below */) | ||
| − | -> decltype(!std:: | + | -> decltype(!std::invoke( |
| − | std:: | + | std::declval<std::decay_t<F> const>(), std::declval<Args>()...)); |
}} | }} | ||
{{dcl end}} | {{dcl end}} | ||
| + | |||
| + | Let {{c|fd}} be the member object of type {{c/core|std::decay_t<F>}}. | ||
{{rrev multi | {{rrev multi | ||
|since1=c++17|rev1= | |since1=c++17|rev1= | ||
@1@ Equivalent to {{c|return !std::invoke(fd, std::forward<Args>(args)...);}} | @1@ Equivalent to {{c|return !std::invoke(fd, std::forward<Args>(args)...);}} | ||
@2@ Equivalent to {{c|return !std::invoke(std::move(fd), std::forward<Args>(args)...);}} | @2@ Equivalent to {{c|return !std::invoke(std::move(fd), std::forward<Args>(args)...);}} | ||
| + | |||
| + | While invoking the result, if the substitution into the return type of the originally selected {{c/core|operator()}} overload fails, [[cpp/language/sfinae|another overload may be selected]]. | ||
|since2=c++20|rev2= | |since2=c++20|rev2= | ||
@1@ [[cpp/language/expressions#Expression-equivalence|Expression-equivalent]] to {{c|!std::invoke(fd, std::forward<Args>(args)...)}} | @1@ [[cpp/language/expressions#Expression-equivalence|Expression-equivalent]] to {{c|!std::invoke(fd, std::forward<Args>(args)...)}} | ||
@2@ [[cpp/language/expressions#Expression-equivalence|Expression-equivalent]] to {{c|!std::invoke(std::move(fd), std::forward<Args>(args)...)}} | @2@ [[cpp/language/expressions#Expression-equivalence|Expression-equivalent]] to {{c|!std::invoke(std::move(fd), std::forward<Args>(args)...)}} | ||
| + | |||
| + | While invoking the result, if the substitution into the return type of the originally selected {{c/core|operator()}} overload fails, the invocation is ill-formed, which can also be a [[cpp/language/sfinae|substitution failure]]. | ||
}} | }} | ||
| − | |||
}} | }} | ||
@2@ A value of the following type. | @2@ A value of the following type. | ||
| Line 109: | Line 117: | ||
constexpr auto operator()( Args&&... args ) const | constexpr auto operator()( Args&&... args ) const | ||
noexcept(/* see below */) | noexcept(/* see below */) | ||
| − | -> decltype( | + | -> decltype(!std::invoke(ConstFn, std::declval<Args>()...)); |
| − | + | ||
}} | }} | ||
Latest revision as of 03:02, 11 January 2024
| Defined in header <functional>
|
||
template< class F > /* unspecified */ not_fn( F&& f ); |
(1) | (since C++17) (constexpr since C++20) |
template< auto ConstFn > constexpr /* unspecified */ not_fn() noexcept; |
(2) | (since C++26) |
1) Creates a forwarding call wrapper that returns the negation of the callable object it holds.
2) Creates a forwarding call wrapper that returns the negation of the statically determined callable target. The program is ill-formed if
ConstFn is a null pointer or null pointer-to-member.Contents |
[edit] 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. | ||
[edit] Return value
1) 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) | (since C++17) (constexpr since C++20) (exposition only*) |
| T( T&& f ) = default; T( const T& f ) = default; |
(2) | (since C++17) |
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.
|
The explicitly defaulted definitions make the return type not assignable. |
(until C++20) |
|
It is unspecified whether these constructors are explicitly defaulted and whether the return type is assignable. |
(since C++20) |
Member function operator()
| (1) | ||
template< class... Args > auto operator()( Args&&... args ) & |
(since C++17) (until C++20) |
|
| template< class... Args > constexpr auto operator()( Args&&... args ) & |
(since C++20) | |
| (2) | ||
template< class... Args > auto operator()( Args&&... args ) && |
(since C++17) (until C++20) |
|
| template< class... Args > constexpr auto operator()( Args&&... args ) && |
(since C++20) | |
Let fd be the member object of type std::decay_t<F>.
|
1) Equivalent to return !std::invoke(fd, std::forward<Args>(args)...);
2) Equivalent to return !std::invoke(std::move(fd), std::forward<Args>(args)...);
While invoking the result, if the substitution into the return type of the originally selected operator() overload fails, another overload may be selected. |
(since C++17) (until C++20) |
|
While invoking the result, if the substitution into the return type of the originally selected operator() overload fails, the invocation is ill-formed, which can also be a substitution failure. |
(since C++20) |
2) A value of the following type.
std::not_fn stateless return type
The return type is a CopyConstructible stateless class. It is unspecified whether the return type is assignable.
Member function operator()
| template< class... Args > constexpr auto operator()( Args&&... args ) const |
(since C++26) | |
Expression-equivalent to !std::invoke(ConstFn, std::forward<Args>(args)...).
[edit] Exceptions
1) Throws no exceptions, unless the construction of fd throws.
[edit] Possible implementation
| (1) not_fn |
|---|
namespace detail { template<class V, class F, class... Args> constexpr bool negate_invocable_impl = false; template<class F, class... Args> constexpr bool negate_invocable_impl<std::void_t<decltype( !std::invoke(std::declval<F>(), std::declval<Args>()...))>, F, Args...> = true; template<class F, class... Args> constexpr bool negate_invocable_v = negate_invocable_impl<void, F, Args...>; template<class F> struct not_fn_t { F f; template<class... Args, std::enable_if_t<negate_invocable_v<F&, Args...>, int> = 0> constexpr decltype(auto) operator()(Args&&... args) & noexcept(noexcept(!std::invoke(f, std::forward<Args>(args)...))) { return !std::invoke(f, std::forward<Args>(args)...); } template<class... Args, std::enable_if_t<negate_invocable_v<const F&, Args...>, int> = 0> constexpr decltype(auto) operator()(Args&&... args) const& noexcept(noexcept(!std::invoke(f, std::forward<Args>(args)...))) { return !std::invoke(f, std::forward<Args>(args)...); } template<class... Args, std::enable_if_t<negate_invocable_v<F, Args...>, int> = 0> constexpr decltype(auto) operator()(Args&&... args) && noexcept(noexcept(!std::invoke(std::move(f), std::forward<Args>(args)...))) { return !std::invoke(std::move(f), std::forward<Args>(args)...); } template<class... Args, std::enable_if_t<negate_invocable_v<const F, Args...>, int> = 0> constexpr decltype(auto) operator()(Args&&... args) const&& noexcept(noexcept(!std::invoke(std::move(f), std::forward<Args>(args)...))) { return !std::invoke(std::move(f), std::forward<Args>(args)...); } // Deleted overloads are needed since C++20 // for preventing a non-equivalent but well-formed overload to be selected. template<class... Args, std::enable_if_t<!negate_invocable_v<F&, Args...>, int> = 0> void operator()(Args&&...) & = delete; template<class... Args, std::enable_if_t<!negate_invocable_v<const F&, Args...>, int> = 0> void operator()(Args&&...) const& = delete; template<class... Args, std::enable_if_t<!negate_invocable_v<F, Args...>, int> = 0> void operator()(Args&&...) && = delete; template<class... Args, std::enable_if_t<!negate_invocable_v<const F, Args...>, int> = 0> void operator()(Args&&...) const&& = delete; }; } template<class F> constexpr detail::not_fn_t<std::decay_t<F>> not_fn(F&& f) { return {std::forward<F>(f)}; } |
| (2) not_fn |
namespace detail { template<auto ConstFn> struct stateless_not_fn { template<class... Args> constexpr auto operator()(Args&&... args) const noexcept(noexcept(!std::invoke(ConstFn, std::forward<Args>(args)...))) -> decltype(!std::invoke(ConstFn, std::forward<Args>(args)...)) { return !std::invoke(ConstFn, std::forward<Args>(args)...); } }; } template<auto ConstFn> constexpr detail::stateless_not_fn<ConstFn> not_fn() noexcept { if constexpr (std::is_pointer_v<decltype(ConstFn)> || std::is_member_pointer_v<decltype(ConstFn)>) static_assert(ConstFn != nullptr); return {}; } |
[edit] Notes
std::not_fn is intended to replace the C++03-era negators std::not1 and std::not2.
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_not_fn |
201603L | (C++17) | std::not_fn(), (1)
|
| 202306L | (C++26) | Allow passing callable objects as non-type template arguments to std::not_fn, (2)
|
[edit] Example
Run this code
#include <cassert> #include <functional> bool is_same(int a, int b) noexcept { return a == b; } struct S { int val; bool is_same(int arg) const noexcept { return val == arg; } }; int main() { // Using with a free function: auto is_differ = std::not_fn(is_same); assert(is_differ(8, 8) == false); // equivalent to: !is_same(8, 8) == false assert(is_differ(6, 9) == true); // equivalent to: !is_same(8, 0) == true // Using with a member function: auto member_differ = std::not_fn(&S::is_same); assert(member_differ(S{3}, 3) == false); //: S tmp{6}; !tmp.is_same(6) == false // Noexcept-specification is preserved: static_assert(noexcept(is_differ) == noexcept(is_same)); static_assert(noexcept(member_differ) == noexcept(&S::is_same)); // Using with a function object: auto same = [](int a, int b) { return a == b; }; auto differ = std::not_fn(same); assert(differ(1, 2) == true); //: !same(1, 2) == true assert(differ(2, 2) == false); //: !same(2, 2) == false #if __cpp_lib_not_fn >= 202306L auto is_differ_cpp26 = std::not_fn<is_same>(); assert(is_differ_cpp26(8, 8) == false); assert(is_differ_cpp26(6, 9) == true); auto member_differ_cpp26 = std::not_fn<&S::is_same>(); assert(member_differ_cpp26(S{3}, 3) == false); auto differ_cpp26 = std::not_fn<same>(); static_assert(differ_cpp26(1, 2) == true); static_assert(differ_cpp26(2, 2) == false); #endif }
[edit] 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) |
