Movatterモバイル変換


[0]ホーム

URL:


cppreference.com
Namespaces
Variants
    Actions

      std::indirectly_unary_invocable,std::indirectly_regular_unary_invocable

      From cppreference.com
      <cpp‎ |iterator
       
       
      Iterator library
      Iterator concepts
      Iterator primitives
      Algorithm concepts and utilities
      Indirect callable concepts
      indirectly_unary_invocableindirectly_regular_unary_invocable
      (C++20)(C++20)  
      Common algorithm requirements
      (C++20)
      (C++20)
      (C++20)
      Utilities
      (C++20)
      Iterator adaptors
      Range access
      (C++11)(C++14)
      (C++14)(C++14)  
      (C++11)(C++14)
      (C++14)(C++14)  
      (C++17)(C++20)
      (C++17)
      (C++17)
       
      Defined in header<iterator>
      std::indirectly_unary_invocable
      template<class F,class I>

          concept indirectly_unary_invocable=
             std::indirectly_readable<I>&&
             std::copy_constructible<F>&&
             std::invocable<F&,/*indirect-value-t*/<I>>&&
             std::invocable<F&,std::iter_reference_t<I>>&&
             std::common_reference_with<
                 std::invoke_result_t<F&,/*indirect-value-t*/<I>>,

                 std::invoke_result_t<F&,std::iter_reference_t<I>>>;
      (since C++20)
      std::indirectly_regular_unary_invocable
      template<class F,class I>

          concept indirectly_regular_unary_invocable=
             std::indirectly_readable<I>&&
             std::copy_constructible<F>&&
             std::regular_invocable<F&,/*indirect-value-t*/<I>>&&
             std::regular_invocable<F&,std::iter_reference_t<I>>&&
             std::common_reference_with<
                 std::invoke_result_t<F&,/*indirect-value-t*/<I>>,

                 std::invoke_result_t<F&,std::iter_reference_t<I>>>;
      (since C++20)

      The conceptsindirectly_unary_invocable andindirectly_regular_unary_invocable specify requirements for algorithms that call (regular) unary invocables as their arguments. The key difference between these concepts andstd::invocable is that they are applied to the type theI references, rather thanI itself.

      [edit]Notes

      The distinction betweenindirectly_unary_invocable andindirectly_regular_unary_invocable is purely semantic.

      [edit]Example

      Run this code
      #include <algorithm>#include <iterator>#include <print>#include <ranges> struct IntWrapper{int i; explicit IntWrapper(int i): i(i){}    IntWrapper(IntWrapper&&)=default;    IntWrapper& operator=(IntWrapper&&)=default;}; int main(){auto ints= std::views::iota(1,10);auto print=[](IntWrapper w){std::print("{} ", w.i);};auto wrap=[](int i){return IntWrapper{i};}; using Proj= std::projected<decltype(ints.begin()), decltype(wrap)>; // error (evaluated to false) until P2609R3:// this was because 'std::iter_value_t<Proj> &' is the same as 'IntWrapper&'// which is not convertible to 'IntWrapper' (implicitly deleted copy ctor)    static_assert(std::indirectly_unary_invocable<decltype(print), Proj>); // if the compile-time check above evaluates to true, then this is well-formed:    std::ranges::for_each(ints, print, wrap);}

      Output:

      1 2 3 4 5 6 7 8 9

      [edit]Defect reports

      The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

      DRApplied toBehavior as publishedCorrect behavior
      P2609R3C++20some requirements were defined in terms ofstd::iter_value_t<I>&
      which mishandled projections resulting in incompatibility with invocableF&
      defined in terms of/*indirect-value-t*/<I>
      to correctly handle such projections
      P2997R1C++20corresponding concepts requiredF& to satisfyinvocable and
      regular_invocable, respectively, withstd::iter_common_reference_t<I>
      does not require
      Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/iterator/indirectly_unary_invocable&oldid=175477"

      [8]ページ先頭

      ©2009-2025 Movatter.jp