std::projected - cppreference.com (original) (raw)
| Defined in header | ||
|---|---|---|
| (1) | ||
| template< std::indirectly_readable I, std::indirectly_regular_unary_invocable<I> Proj > struct projected { using value_type = std::remove_cvref_t <std::indirect_result_t<Proj&, I>>; std::indirect_result_t<Proj&, I> operator*() const; // not defined }; | (since C++20) (until C++26) | |
| template< std::indirectly_readable I, std::indirectly_regular_unary_invocable<I> Proj > using projected = /*projected-impl*/<I, Proj>::/*type*/; | (since C++26) | |
| template< std::weakly_incrementable I, class Proj > struct incrementable_traits<std::projected<I, Proj>> { using difference_type = std::iter_difference_t<I>; }; | (2) | (since C++20) (until C++26) |
| Helper templates | ||
| template< class I, class Proj > struct /*projected-impl*/ { struct /*type*/ { using value_type = std::remove_cvref_t <std::indirect_result_t<Proj&, I>>; using difference_type = std::iter_difference_t<I>; // conditionally present std::indirect_result_t<Proj&, I> operator*() const; // not defined }; }; | (3) | (since C++26) (exposition only*) |
- Class(until C++26)Alias(since C++26) template
projectedcombines an indirectly_readable typeIand a callable object typeProjinto a newindirectly_readabletype whose reference type is the result of applyingProjto the std::iter_reference_t<I>.
For the exposition-only nested class /*type*/, the nested type difference_type exists only if I models weakly_incrementable.
projected is used only to constrain algorithms that accept callable objects and projections, and hence its operator*() is not defined.
[edit] Template parameters
| I | - | an indirectly readable type |
|---|---|---|
| Proj | - | projection applied to a dereferenced I |
[edit] Notes
The indirect layer prevents I and Proj to be associated classes of projected. When an associated class of I or Proj is an incomplete class type, the indirect layer avoids the unnecessary attempt to inspect the definition of that type that results in hard error.