Namespaces
Variants

std::experimental:: not_fn

From cppreference.net
C++
Experimental
Library fundamentals v2
In ISO C++ integriert Die auf dieser Seite beschriebene Funktionalität wurde ab 3/2016 in den Hauptstandard von ISO C++ übernommen, siehe std::not_fn (seit C++17)
Definiert in Header <experimental/functional>
template < class F >
/*unspecified*/ not_fn ( F && f ) ;
(Library Fundamentals TS v2)

Erstellt einen Weiterleitungsaufruf-Wrapper, der das Komplement des aufrufbaren Objekts zurückgibt, das er enthält.

Inhaltsverzeichnis

Parameter

f - das Objekt, von dem das Callable Objekt, das vom Wrapper gehalten wird, konstruiert wird

Rückgabewert

Sei FD gleich std:: decay_t < F > und fd ein Lvalue vom Typ FD , konstruiert aus std:: forward < F > ( f ) .

not_fn gibt einen weiterleitenden Aufruf-Wrapper fn eines nicht näher spezifizierten Typs zurück, sodass fn ( a1, a2, ..., aN ) äquivalent zu ! INVOKE ( fd, a1, ..., aN ) ist, wobei INVOKE die in Callable beschriebene Operation bezeichnet.

Der zurückgegebene Aufruf-Wrapper ist immer MoveConstructible und ist CopyConstructible , wenn FD CopyConstructible ist.

Anmerkungen

Wenn fd nicht Callable ist, oder std:: is_constructible < FD, F > :: value nicht true ist, ist das Verhalten undefiniert.

Ausnahmen

Wirft keine Ausnahmen, es sei denn, die Konstruktion von fd wirft.

Mögliche Implementierung 

namespace detail {
    template<class F>
    struct not_fn_t {
        F f;
        template<class... Args>
        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)...);
        }
        // cv-qualifizierte Überladung für QoI
        template<class... Args>
        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>
        auto operator()(Args&&... args) volatile
            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>
        auto operator()(Args&&... args) const volatile
            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 F>
detail::not_fn_t<std::decay_t<F>> not_fn(F&& f) { return { std::forward<F>(f) }; }

Hinweise

not_fn soll die Negatoren aus der C++03-Ära std::not1 und std::not2 ersetzen.

Siehe auch

(C++17)
erstellt ein Funktionsobjekt, das das Komplement des Ergebnisses des von ihm gehaltenen Funktionsobjekts zurückgibt
(Funktions-Template)