FreeBSD Manual Pages
std::not_fn(3) C++ Standard Libary std::not_fn(3) NAME std::not_fn - std::not_fn Synopsis Defined in header <functional> template< class F> (since C++17) /*unspecified*/ not_fn( F&& f ); (until C++20) template< class F> (since C++20) constexpr /*unspecified*/ not_fn( F&& f ); 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 MoveCon- structible. - 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 mem- bers: 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); // exposition only (since C++17) (until C++20) explicit constexpr T(F&& f); // exposition only (1) (since C++20) T(T&& f) = default; (2) T(const T& f) = default; 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() template<class... Args> auto operator()(Args&&... args) & -> decltype( !std::declval<std::invoke_result_t<std::decay_t<F>&, (since Args...>>()); C++17) template<class... Args> auto operator()(Args&&... args) (until const& C++20) -> decltype( !std::declval<std::invoke_result_t<std::decay_t<F> const&, Args...>>()); template<class... Args> constexpr auto operator()(Args&&... args) & noexcept(/*see below*/) -> decltype( !std::declval<std::invoke_result_t<std::decay_t<F>&, Args...>>()); (since template<class... Args> constexpr auto operator()(Args&&... C++20) args) const& noexcept(/*see below*/) -> decltype( !std::declval<std::invoke_result_t<std::decay_t<F> const&, Args...>>()); (1) template<class... Args> auto operator()(Args&&... args) && -> decltype( !std::declval<std::invoke_result_t<std::decay_t<F>, (since Args...>>()); C++17) template<class... Args> auto operator()(Args&&... args) (until const&& C++20) -> decltype( !std::declval<std::invoke_result_t<std::decay_t<F> const, Args...>>()); template<class... Args> constexpr auto operator()(Args&&... args) && (2) noexcept(/*see below*/) -> decltype( !std::declval<std::invoke_result_t<std::decay_t<F>, Args...>>()); (since template<class... Args> constexpr auto operator()(Args&&... C++20) args) const&& noexcept(/*see below*/) -> decltype( !std::declval<std::invoke_result_t<std::decay_t<F> const, Args...>>()); 1) Equivalent to return !std::invoke(fd, std::for- ward<Args>(args)...); (since C++17) 2) Equivalent to return !std::invoke(std::move(fd), (until C++20) std::forward<Args>(args)...); 1) Expression-equivalent to !std::invoke(fd, std::forward<Args>(args)...) (since C++20) 2) Expression-equivalent to !std::invoke(std::move(fd), std::forward<Args>(args)...) where fd is the member object of type std::decay_t<F> Expression-equivalent Expression e is expression-equivalent to expression f, if * e and f 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 poten- tially-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::for- ward<Args>(args)...))) -> decltype(!std::invoke(f, std::for- ward<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::for- ward<Args>(args)...))) -> decltype(!std::invoke(f, std::for- ward<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::for- ward<Args>(args)...))) -> decltype(!std::invoke(std::move(f), std::for- ward<Args>(args)...)) { return !std::invoke(std::move(f), std::for- ward<Args>(args)...); } template<class... Args> constexpr auto operator()(Args&&... args) const&& noexcept(noexcept(!std::invoke(std::move(f), std::for- ward<Args>(args)...))) -> decltype(!std::invoke(std::move(f), std::for- ward<Args>(args)...)) { return !std::invoke(std::move(f), std::for- ward<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-test macro: __cpp_lib_not_fn Example This section is incomplete Reason: no example See also not1 constructs custom std::unary_negate object (deprecated in C++17) (function template) (removed in C++20) not2 constructs custom std::binary_negate object (deprecated in C++17) (function template) (removed in C++20) http://cppreference.com 2022.07.31 std::not_fn(3)
NAME | Synopsis | Parameters | Type requirements | Return value | Member objects | Member function operator() | Exceptions | Possible implementation | Notes | Example | See also
Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::not_fn&sektion=3&manpath=FreeBSD+Ports+15.0>