Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/iterator/indirectly readable"

From cppreference.com
< cpp‎ | iterator
m (fmt)
Line 2: Line 2:
 
{{cpp/iterator/navbar}}
 
{{cpp/iterator/navbar}}
 
{{dcl begin}}
 
{{dcl begin}}
{{dcl header | iterator}}
+
{{dcl header|iterator}}
{{dcl | since=c++20 | 1=
+
{{dcl|since=c++20|1=
 
template< class In >
 
template< class In >
 
   concept __IndirectlyReadableImpl = // exposition only
 
   concept __IndirectlyReadableImpl = // exposition only
Line 23: Line 23:
 
     >;
 
     >;
 
}}
 
}}
{{dcl | since=c++20 | 1=
+
{{dcl|since=c++20|1=
 
template< class In >
 
template< class In >
 
   concept indirectly_readable =
 
   concept indirectly_readable =
Line 33: Line 33:
  
 
===Semantic requirements===
 
===Semantic requirements===
Given a value {{tt|i}} of type {{tt|I}}, {{tt|I}} models {{tt|indirectly_readable}} only if all concepts it subsumes are modeled and the expression {{c|*i}} is equality preserving.
+
Given a value {{tt|i}} of type {{tt|I}}, {{tt|I}} models {{tt|indirectly_readable}} only if all concepts it subsumes are modeled and the expression {{c|*i}} is [[cpp/concepts#Equality preservation|equality-preserving]].
  
 
{{cpp/concepts/equality preservation}}
 
{{cpp/concepts/equality preservation}}
  
 
{{langlinks|cs|de|es|fr|it|ja|ko|pl|pt|ru|zh}}
 
{{langlinks|cs|de|es|fr|it|ja|ko|pl|pt|ru|zh}}

Revision as of 12:33, 25 February 2023

 
 
Iterator library
Iterator concepts
indirectly_readable
(C++20)
Iterator primitives
Algorithm concepts and utilities
Indirect callable concepts
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>
template< class In >

  concept __IndirectlyReadableImpl = // exposition only
    requires(const In in) {
      typename std::iter_value_t<In>;
      typename std::iter_reference_t<In>;
      typename std::iter_rvalue_reference_t<In>;
      { *in } -> std::same_as<std::iter_reference_t<In>>;
      { ranges::iter_move(in) } -> std::same_as<std::iter_rvalue_reference_t<In>>;
    } &&
    std::common_reference_with<
      std::iter_reference_t<In>&&, std::iter_value_t<In>&
    > &&
    std::common_reference_with<
      std::iter_reference_t<In>&&, std::iter_rvalue_reference_t<In>&&
    > &&
    std::common_reference_with<
      std::iter_rvalue_reference_t<In>&&, const std::iter_value_t<In>&

    >;
(since C++20)
template< class In >

  concept indirectly_readable =

    __IndirectlyReadableImpl<std::remove_cvref_t<In>>;
(since C++20)

The concept indirectly_readable is modeled by types that are readable by applying operator*, such as pointers, smart pointers, and input iterators.

Semantic requirements

Given a value i of type I, I models indirectly_readable only if all concepts it subsumes are modeled and the expression *i is equality-preserving.

Equality preservation

Expressions declared in requires expressions of the standard library concepts are required to be equality-preserving (except where stated otherwise).