Spec-Zone.ru › C++

std::not_fn

Определено в заголовочном файле <functional> 
template< class F >
/* unspecified */ not_fn( F&& f );
(1) (начиная с C++17)
(constexpr начиная с C++20) 
template< auto ConstFn >
constexpr /* unspecified */ not_fn() noexcept;
(2) (начиная с C++26)
1) Создаёт пересылающую обёртку вызова, которая возвращает отрицание вызываемого объекта, хранящегося в ней.
2) Создаёт пересылающую обёртку вызова, которая возвращает отрицание статически определённой вызываемой цели. Программа некорректна, если ConstFn является нулевым указателем или нулевым указателем на член.

Параметры

f - объект, из которого конструируется объект Callable, хранящийся в обёртке
Требования к типам
-std::decay_t<F> должен соответствовать требованиям Callable и MoveConstructible.
-std::is_constructible_v<std::decay_t<F>, F> должен быть true.

Возвращаемое значение

1) Объект-функция неопределённого типа T. Он имеет следующие члены.

std::not_fn тип возвращаемого значения

Объекты-члены

Тип возвращаемого значения std::not_fn содержит объект-член типа std::decay_t<F>.

Конструкторы

explicit T( F&& f );
(1) (начиная с C++17)
(constexpr начиная с C++20)
(только для пояснения*) 
T( T&& f ) = default;
T( const T& f ) = default;
(2) (начиная с C++17)
1) Конструктор выполняет прямую инициализацию без списка инициализаторов объекта-члена (типа std::decay_t<F>) из std::forward<F>(f). Выбрасывает любое исключение, выброшенное выбранным конструктором.
2) Поскольку std::decay_t<F> должен соответствовать требованиям MoveConstructible, возвращаемая обёртка вызова всегда является MoveConstructible и является CopyConstructible, если std::decay_t<F> является CopyConstructible.

Явно заданные по умолчанию определения делают тип возвращаемого значения неназначаемым.

 (до C++20)

Не указано, заданы ли эти конструкторы явно по умолчанию и является ли тип возвращаемого значения назначаемым.

 (начиная с C++20)

Функция-член operator() 

template< class... Args >
auto operator()( Args&&... args ) &
-> decltype(!std::declval<
    std::invoke_result_t<std::decay_t<F>&, Args...>>());
template< class... Args >
auto operator()( Args&&... args ) const&
-> decltype(!std::declval<
    std::invoke_result_t<std::decay_t<F> const&, Args...>>());
(1) (начиная с C++17)
(до C++20) 
template< class... Args >
constexpr auto operator()( Args&&... args ) &
    noexcept(/* see below */)
-> decltype(!std::invoke(
    std::declval<std::decay_t<F>&>(), std::declval<Args>()...));
template< class... Args >
constexpr auto operator()( Args&&... args ) const&
    noexcept(/* see below */)
-> decltype(!std::invoke(
    std::declval<std::decay_t<F> const&>(), std::declval<Args>()...));
(начиная с C++20) 
template< class... Args >
auto operator()( Args&&... args ) &&
-> decltype(!std::declval<
    std::invoke_result_t<std::decay_t<F>, Args...>>());
template< class... Args >
auto operator()( Args&&... args ) const&&
-> decltype(!std::declval<
    std::invoke_result_t<std::decay_t<F> const, Args...>>());
(2) (начиная с C++17)
(до C++20) 
template< class... Args >
constexpr auto operator()( Args&&... args ) &&
    noexcept(/* see below */)
-> decltype(!std::invoke(
    std::declval<std::decay_t<F>>(), std::declval<Args>()...));
template< class... Args >
constexpr auto operator()( Args&&... args ) const&&
    noexcept(/* see below */)
-> decltype(!std::invoke(
    std::declval<std::decay_t<F> const>(), std::declval<Args>()...));
(начиная с C++20)

Пусть fd будет объектом-членом типа std::decay_t<F>.

1) Эквивалентно return !std::invoke(fd, std::forward<Args>(args)...); 2) Эквивалентно return !std::invoke(std::move(fd), std::forward<Args>(args)...);

При вызове результата, если подстановка в тип возвращаемого значения первоначально выбранной перегрузки operator() завершается неудачей, может быть выбрана другая перегрузка.

 (начиная с C++17)
(до C++20)
1) Эквивалентно выражению !std::invoke(fd, std::forward<Args>(args)...) 2) Эквивалентно выражению !std::invoke(std::move(fd), std::forward<Args>(args)...)

При вызове результата, если подстановка в тип возвращаемого значения первоначально выбранной перегрузки operator() завершается неудачей, вызов является некорректным; это также может быть ошибкой подстановки.

 (начиная с C++20)
2) Значение следующего типа.

std::not_fn тип возвращаемого значения без состояния

Тип возвращаемого значения представляет собой класс без состояния, соответствующий требованиям CopyConstructible. Не указано, является ли тип возвращаемого значения назначаемым.

Функция-член operator() 

template< class... Args >
constexpr auto operator()( Args&&... args ) const
    noexcept(/* see below */)
-> decltype(!std::invoke(ConstFn, std::declval<Args>()...));
(начиная с C++26)

Эквивалентно выражению !std::invoke(ConstFn, std::forward<Args>(args)...).

Исключения

1) Исключения не выбрасываются, если только конструирование fd не приводит к исключению.

Возможная реализация

(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::invoke(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(!std::invoke(f, std::forward<Args>(args)...)))
        {
            return !std::invoke(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::invoke(f, std::forward<Args>(args)...)))
        {
            return !std::invoke(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::invoke(std::move(f), std::forward<Args>(args)...)))
        {
            return !std::invoke(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::invoke(std::move(f), std::forward<Args>(args)...)))
        {
            return !std::invoke(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(!std::invoke(ConstFn, std::forward<Args>(args)...)))
            -> decltype(!std::invoke(ConstFn, std::forward<Args>(args)...))
        {
            return !std::invoke(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)> ||
                  std::is_member_pointer_v<decltype(ConstFn)>)
        static_assert(ConstFn != nullptr);

    return {};
}

Примечания

std::not_fn предназначена для замены отрицателей эпохи C++03 std::not1 и std::not2.

Макрос проверки поддержки возможностей Значение Стандарт Возможность
__cpp_lib_not_fn 201603L (C++17) std::not_fn(), (1)
202306L (C++26) Разрешить передачу вызываемых объектов в качестве аргументов шаблона, не являющихся типами, в std::not_fn, (2)

Пример

#include <cassert>
#include <functional>

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

См. также

not1
(устарела в C++17)(удалена в C++20)
 создаёт пользовательский объект std::unary_negate
(шаблон функции)
not2
(устарела в C++17)(удалена в C++20)
 создаёт пользовательский объект std::binary_negate
(шаблон функции)

© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/cpp/utility/functional/not_fn

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API