Namespaces
Variants

std::experimental:: not_fn

From cppreference.net
C++
Experimental
Library fundamentals v2
Incorporado en ISO C++ La funcionalidad descrita en esta página fue incorporada al estándar principal de ISO C++ a partir de 3/2016, consulte std::not_fn (desde C++17)
Definido en el encabezado <experimental/functional>
template < class F >
/*unspecified*/ not_fn ( F && f ) ;
(library fundamentals TS v2)

Crea un envoltorio de llamada de reenvío que devuelve el complemento del objeto invocable que contiene.

Contenidos

Parámetros

f - el objeto desde el cual se construye Callable el objeto contenido en el envoltorio

Valor de retorno

Sea FD std:: decay_t < F > y fd un lvalue de tipo FD construido a partir de std:: forward < F > ( f ) .

not_fn devuelve un envoltorio de llamada de reenvío fn de tipo no especificado tal que fn ( a1, a2, ..., aN ) es equivalente a ! INVOKE ( fd, a1, ..., aN ) , donde INVOKE es la operación descrita en Callable .

El contenedor de llamadas devuelto es siempre MoveConstructible , y es CopyConstructible si FD es CopyConstructible .

Observaciones

Si fd no es Callable , o std:: is_constructible < FD, F > :: value no es true , el comportamiento es indefinido.

Excepciones

No lanza excepciones, a menos que la construcción de fd lo haga.

Implementación posible 

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)...);
        }
        // sobrecarga calificada cv para 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) }; }

Notas

not_fn está diseñado para reemplazar los negadores de la era C++03 std::not1 y std::not2 .

Véase también

(C++17)
crea un objeto función que devuelve el complemento del resultado del objeto función que contiene
(plantilla de función)