Namespaces
Variants

    cpp/iterator/incrementable: Difference between revisions

    From cppreference.com
    ← Older edit
    Space Mission (talk | contribs)
    19,873 edits
    Andreas Krug (talk | contribs)
    8,213 edits
    m fmt, .
     
    Line 4: Line 4:
    {{dcl header|iterator|since=c++20}}
    {{dcl header|iterator|since=c++20}}
    {{dcl|since=c++20|1=
    {{dcl|since=c++20|1=
    template<class I>
    template< class I >
         concept incrementable =
         concept incrementable =
             std::regular<I> &&
             std::regular<I> &&
    Line 21: Line 21:
    {{tt|I}} models {{tt|std::incrementable}} only if given any two incrementable objects {{tt|a}} and {{tt|b}} of type {{tt|I}}:
    {{tt|I}} models {{tt|std::incrementable}} only if given any two incrementable objects {{tt|a}} and {{tt|b}} of type {{tt|I}}:
    * {{c|1=bool(a == b)}} implies {{c|1=bool(a++ == b)}}, and
    * {{c|1=bool(a == b)}} implies {{c|1=bool(a++ == b)}}, and
    * {{c|1=bool(a == b)}} implies {{c|1=bool(((void)a++, a) == ++b)}}
    * {{c|1=bool(a == b)}} implies {{c|1=bool(((void)a++, a) == ++b)}}


    {{cpp/concepts/equality preservation}}
    {{cpp/concepts/equality preservation}}

    Latest revision as of 06:03, 1 October 2023

     
    C++
     
    Iterator library
    Iterator concepts
    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 I >
    concept incrementable =
        std::regular<I> &&
        std::weakly_incrementable<I> &&
        requires(I i) {
            { i++ } -> std::same_as<I>;
        };
    		(since C++20)

    This concept specifies requirements on types that can be incremented with the pre- and post-increment operators, whose increment operations are equality-preserving, and the type is std::equality_comparable.

    Unlike with std::weakly_incrementable, which only support single-pass algorithms, multi-pass one-directional algorithms can be used with types that model std::incrementable.

    Semantic requirements

    I models std::incrementable only if given any two incrementable objects a and b of type I:

    • bool(a == b) implies bool(a++ == b), and
    • bool(a == b) implies bool(((void)a++, a) == ++b).

    Equality preservation

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

    See also

    (C++20)
    		 specifies that a semiregular type can be incremented with pre- and post-increment operators
    (concept) [edit]
    (C++20)
    		 specifies that a type is the same as another type
    (concept) [edit]