Movatterモバイル変換

[0]ホーム
URL:

cppreference.com
Namespaces
Variants
    Actions

      std::not_fn

      From cppreference.com
      <cpp‎ |utility‎ |functional
       
       
      Utilities library
       
      Function objects
      Function invocation
      (C++17)(C++23)
      Identity function object
      (C++20)
      Old binders and adaptors
      (until C++17*)
      (until C++17*)
      (until C++17*)
      (until C++17*)  
      (until C++17*)
      (until C++17*)(until C++17*)(until C++17*)(until C++17*)
      (until C++20*)
      (until C++20*)
      (until C++17*)(until C++17*)
      (until C++17*)(until C++17*)

      (until C++17*)
      (until C++17*)(until C++17*)(until C++17*)(until C++17*)
      (until C++20*)
      (until C++20*)
       
      Defined in header<functional>
      template<class F>
      /* unspecified */ not_fn( F&& f);
      		 (1)(since C++17)
      (constexpr since C++20)
      template<auto ConstFn>
      constexpr/* unspecified */ not_fn()noexcept;
      		 (2)(since C++26)
      1) Creates a forwarding call wrapper that returns the negation of the callable object it holds.
      2) Creates a forwarding call wrapper that returns the negation of the statically determined callable target. The program is ill-formed ifConstFn is a null pointer or null pointer-to-member.

      Contents

      [edit]Parameters

      f - the object from which theCallable object held by the wrapper is constructed
      Type requirements
      -
      std::decay_t<F> must meet the requirements ofCallable andMoveConstructible.
      -
      std::is_constructible_v<std::decay_t<F>, F> is required to betrue.

      [edit]Return value

      1) A function object of unspecified typeT. It has the following members.

      std::not_fnreturn type

      Member objects

      The return type ofstd::not_fn holds a member object of typestd::decay_t<F>.

      Constructors

      explicit T( F&& f);
      		 (1)(since C++17)
      (constexpr since C++20)
      (exposition only*)
      T( T&& f)=default;
      T(const T& f)=default;
      		 (2)(since C++17)
      1) The constructor direct-non-list-initializes the member object (of typestd::decay_t<F>) fromstd::forward<F>(f). Throws any exception thrown by the constructor selected.
      2) Becausestd::decay_t<F> is required to beMoveConstructible, the returned call wrapper is alwaysMoveConstructible, and isCopyConstructible ifstd::decay_t<F> isCopyConstructible.

      The explicitly defaulted definitions make the return type not assignable.

      		(until C++20)

      It is unspecified whether these constructors are explicitly defaulted and whether the return type is assignable.

      		(since C++20)

      Member functionoperator()

      (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...>>());
      		(since C++17)
      (until C++20)
      template<class...Args>

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

         std::declval<std::decay_t<F>const&>(),std::declval<Args>()...));
      		(since 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...>>());
      		(since C++17)
      (until C++20)
      template<class...Args>

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

         std::declval<std::decay_t<F>const>(),std::declval<Args>()...));
      		(since C++20)

      Letfd be the member object of typestd::decay_t<F>.

      1) Equivalent toreturn!std::invoke(fd,std::forward<Args>(args)...);
      2) Equivalent toreturn!std::invoke(std::move(fd),std::forward<Args>(args)...);

      While invoking the result, if the substitution into the return type of the originally selectedoperator() overload fails,another overload may be selected.

      		(since C++17)
      (until C++20)
      2)Expression-equivalent to!std::invoke(std::move(fd),std::forward<Args>(args)...)

      While invoking the result, if the substitution into the return type of the originally selectedoperator() overload fails, the invocation is ill-formed, which can also be asubstitution failure.

      		(since C++20)
      2) A value of the following type.

      std::not_fnstateless return type

      The return type is aCopyConstructible stateless class. It is unspecified whether the return type is assignable.

      Member functionoperator()

      template<class...Args>

      constexprauto operator()( Args&&...args)const
         noexcept(/* see below */)

      -> decltype(!std::invoke(ConstFn,std::declval<Args>()...));
      		(since C++26)

      Expression-equivalent to!std::invoke(ConstFn,std::forward<Args>(args)...).

      [edit]Exceptions

      1) Throws no exceptions, unless the construction offd throws.

      [edit]Possible implementation

      (1) not_fn
      namespace detail{template<class V,class F,class...Args>constexprbool negate_invocable_impl=false;template<class F,class...Args>constexprbool negate_invocable_impl<std::void_t<decltype(!std::invoke(std::declval<F>(),std::declval<Args>()...))>, F, Args...>=true; template<class F,class...Args>constexprbool 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>constexprauto operator()(Args&&...args)constnoexcept(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{ifconstexpr(std::is_pointer_v<decltype(ConstFn)>||std::is_member_pointer_v<decltype(ConstFn)>)        static_assert(ConstFn!= nullptr); return{};}

      [edit]Notes

      std::not_fn is intended to replace the C++03-era negatorsstd::not1 andstd::not2.

      Feature-test macroValueStdFeature
      __cpp_lib_not_fn201603L(C++17)std::not_fn(),(1)
      202306L(C++26)Allow passing callable objects as constant template arguments tostd::not_fn,(2)

      [edit]Example

      Run this code
      #include <cassert>#include <functional> bool is_same(int a,int b)noexcept{return a== b;} struct S{int val;bool is_same(int arg)constnoexcept{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) == falseassert(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) == trueassert(differ(2,2)==false);//: !same(2, 2) == false #if __cpp_lib_not_fn >= 202306Lauto 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}

      [edit]See also

      (deprecated in C++17)(removed in C++20)
      		 constructs customstd::unary_negate object
      (function template)[edit]
      (deprecated in C++17)(removed in C++20)
      		 constructs customstd::binary_negate object
      (function template)[edit]
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/utility/functional/not_fn&oldid=182723"
      [8]ページ先頭
      ©2009-2025 Movatter.jp