Namespaces
Variants

std::experimental:: not_fn

From cppreference.net
C++
Experimental
Library fundamentals v2
Fusionné dans la norme ISO C++ La fonctionnalité décrite sur cette page a été intégrée dans la norme principale ISO C++ à partir de 03/2016, voir std::not_fn (depuis C++17)
Défini dans l'en-tête <experimental/functional>
template < class F >
/*unspecified*/ not_fn ( F && f ) ;
(library fundamentals TS v2)

Crée un wrapper d'appel de transfert qui retourne le complément de l'objet appelable qu'il contient.

Table des matières

Paramètres

f - l'objet à partir duquel l'objet Callable contenu dans le wrapper est construit

Valeur de retour

Soit FD le type std:: decay_t < F > et fd une lvalue de type FD construite à partir de std:: forward < F > ( f ) .

not_fn retourne un wrapper d'appel de transfert fn de type non spécifié tel que fn ( a1, a2, ..., aN ) est équivalent à ! INVOKE ( fd, a1, ..., aN ) , où INVOKE est l'opération décrite dans Callable .

Le wrapper d'appel retourné est toujours MoveConstructible , et est CopyConstructible si FD est CopyConstructible .

Remarques

Si fd n'est pas Callable , ou si std:: is_constructible < FD, F > :: value n'est pas true , le comportement est indéfini.

Exceptions

Ne lance aucune exception, sauf si la construction de fd en lance.

Implémentation possible 

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)...);
        }
        // Surcharge qualifiée cv pour 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) }; }

Notes

not_fn est destiné à remplacer les négateurs de l'ère C++03 std::not1 et std::not2 .

Voir aussi

(C++17)
crée un objet fonction qui retourne le complément du résultat de l'objet fonction qu'il contient
(modèle de fonction)