std::not_fn - cppreference.com (original) (raw)

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

• 1 Parameters
• 2 Return value
• 3 std::not_fn return type
  • 3.1 Member objects
  • 3.2 Constructors
  • 3.3 Member function operator()
• 4 std::not_fn stateless return type
  • 4.1 Member function operator()
  • 4.2 Exceptions
  • 4.3 Possible implementation
  • 4.4 Notes
  • 4.5 Example
  • 4.6 See also

[edit] Parameters

[edit] Return value

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

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 noexcept(/* see below */) -> decltype((ConstFn, std::declval<Args>()...)); | | (since C++26) | | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | ------------- |

Expression-equivalent to (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::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((f, std::forward<Args>(args)...))) { return (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((f, std::forward<Args>(args)...))) { return (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::move(f), std::forward<Args>(args)...))) { return (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::move(f), std::forward<Args>(args)...))) { return (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((ConstFn, std::forward<Args>(args)...))) -> decltype((ConstFn, std::forward<Args>(args)...)) { return (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)> |

[edit] Notes

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

[edit] Example

#include #include   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(); 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(); static_assert(differ_cpp26(1, 2) == true); static_assert(differ_cpp26(2, 2) == false); #endif }

[edit] See also