std::not_fn

来自cppreference.com
< cpp‎ | utility‎ | functional
 
 
工具库
通用工具
格式化库 (C++20)
(C++11)
关系运算符 (C++20 中弃用)
整数比较函数
(C++20)(C++20)(C++20)
(C++20)
swap 与类型运算
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
常用词汇类型
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)

初等字符串转换
(C++17)
(C++17)
栈踪
 
函数对象
函数包装
(C++11)
(C++11)
部分函数应用
(C++11)
(C++20)
函数调用
(C++17)(C++23)
恒等函数对象
(C++20)
引用包装
(C++11)(C++11)
通透运算符包装
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
(C++14)
取反器
not_fn
(C++17)
搜索器
旧绑定器与适配器
(C++17 前)
(C++17 前)
(C++17 前)
(C++17 前)
(C++17 前)(C++17 前)(C++17 前)(C++17 前)
(C++20 前)
(C++20 前)
(C++17 前)(C++17 前)
(C++17 前)(C++17 前)

(C++17 前)
(C++17 前)(C++17 前)(C++17 前)(C++17 前)
(C++20 前)
(C++20 前)
 
定义于头文件 <functional>
template< class F>
/*unspecified*/ not_fn( F&& f );
(C++17 起)
(C++20 前)
template< class F>
constexpr /*unspecified*/ not_fn( F&& f );
(C++20 起)

构造一个转发调用包装器,返回其所保有的可调用对象的逻辑非。

参数

f - 构造包装器所保有的可调用 (Callable) 对象的来源对象
类型要求
-
std::decay_t<F> 必须满足可调用 (Callable) 可移动构造 (MoveConstructible) 的要求。
-
要求 std::is_constructible_v<std::decay_t<F>, F> 为 true

返回值

未指定类型 T 的函数对象。它拥有下列成员:

std::not_fn 返回类型

成员对象

std::not_fn 的返回类型保有一个 std::decay_t<F> 类型的成员对象。

构造函数

(1)
explicit T(F&& f); // 仅用于阐释
(C++17 起)
(C++20 前)
explicit constexpr T(F&& f); // 仅用于阐释
(C++20 起)
T(T&& f) = default;
T(const T& f) = default;
(2)
1) 构造函数从 std::forward<F>(f) 直接非列表初始化成员对象(类型为 std::decay_t<F> )。抛出任何所选构造函数所抛的异常

成员函数 operator()

(1)
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...>>());
(C++17 起)
(C++20 前)
template<class... Args> constexpr auto operator()(Args&&... args) &

   noexcept(/*see below*/)
-> decltype(
    !std::declval<std::invoke_result_t<std::decay_t<F>&, Args...>>());
template<class... Args> constexpr auto operator()(Args&&... args) const&
   noexcept(/*see below*/)
-> decltype(

    !std::declval<std::invoke_result_t<std::decay_t<F> const&, Args...>>());
(C++20 起)
(2)
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...>>());
(C++17 起)
(C++20 前)
template<class... Args> constexpr auto operator()(Args&&... args) &&

   noexcept(/*see below*/)
-> decltype(
    !std::declval<std::invoke_result_t<std::decay_t<F>, Args...>>());
template<class... Args> constexpr auto operator()(Args&&... args) const&&
   noexcept(/*see below*/)
-> decltype(

    !std::declval<std::invoke_result_t<std::decay_t<F> const, Args...>>());
(C++20 起)
1) 等价于 return !std::invoke(fd, std::forward<Args>(args)...)
2) 等价于 return !std::invoke(std::move(fd), std::forward<Args>(args)...)
(C++17 起)
(C++20 前)
1) 表达式等价于 !std::invoke(fd, std::forward<Args>(args)...)
2) 表达式等价于 !std::invoke(std::move(fd), std::forward<Args>(args)...)
(C++20 起)

其中 fd 是 std::decay_t<F> 类型的成员对象

异常

不抛出异常,除非 fd 的构造抛出异常。

可能的实现

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::forward<Args>(args)...)))
            -> decltype(!std::invoke(f, std::forward<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::forward<Args>(args)...)))
            -> decltype(!std::invoke(f, std::forward<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::forward<Args>(args)...)))
            -> decltype(!std::invoke(std::move(f), std::forward<Args>(args)...))
        {
            return !std::invoke(std::move(f), std::forward<Args>(args)...);
        }
 
        template<class... Args>
        constexpr auto operator()(Args&&... args) const&&
            noexcept(noexcept(!std::invoke(std::move(f), std::forward<Args>(args)...)))
            -> decltype(!std::invoke(std::move(f), std::forward<Args>(args)...))
        {
            return !std::invoke(std::move(f), std::forward<Args>(args)...);
        }
    };
}
 
template<class F>
constexpr detail::not_fn_t<std::decay_t<F>> not_fn(F&& f)
{
    return { std::forward<F>(f) };
}

注解

not_fn 的目的是取代 C++03 时代的取反器 std::not1std::not2

示例

参阅

(C++17 中弃用)(C++20 中移除)
构造定制的 std::unary_negate 对象
(函数模板)
(C++17 中弃用)(C++20 中移除)
构造定制的 std::binary_negate 对象
(函数模板)