Namespaces
Variants

    std::ranges::cbegin

    Von de.cppreference.net
     
    C++
     
    Ranges library
    Bereichsanpasser
     
    Definiert in Header <ranges>
    Definiert in Header <iterator> 
    inline namespace /* unspecified */ {
    inline constexpr /* unspecified */ cbegin = /* unspecified */;
}
    		(seit C++20)
    (Anpassungspunktobjekt)
    Aufrufsignatur
    		 
    template< class T >
    requires /* see below */
constexpr /* see below */ auto cbegin( T&& t );
    		(seit C++20)

    Gibt einen Iterator zum ersten Element des const-qualifizierten Arguments zurück.

    		(bis C++23)

    Gibt einen konstanten Iterator zum ersten Element des Arguments zurück.

    		(seit C++23)

    Sei CT

    • const std::remove_reference_t<T>& wenn das Argument ein Lvalue ist (d.h. T ist ein Lvalue-Referenztyp),
    • const T andernfalls.

    Ein Aufruf von ranges::cbegin ist ausdrucksäquivalent zu ranges::begin(static_cast<CT&&>(t)).

    		(bis C++23)

    Wenn das Argument ein Lvalue ist oder ranges::enable_borrowed_range<std::remove_cv_t<T>> ist true, dann ist ein Aufruf von ranges::cbegin ausdrucksäquivalent zu:

    • std::const_iterator<decltype(U)>(U) für einen Ausdruck U äquivalent zu ranges::begin(possibly-const-range(t).

    In allen anderen Fällen ist ein Aufruf von ranges::cbegin fehlerhaft, was zu Substitutionsfehler führen kann, wenn der Aufruf im unmittelbaren Kontext einer Template-Instantiierung auftritt.

    		(seit C++23)

    Der Rückgabetyp modelliert std::input_or_output_iterator und constant-iterator(seit C++23) in allen Fällen.

    Customization Point Objects

    Der Name ranges::cbegin bezeichnet ein Customization Point Object , welches ein konstantes Function Object eines Literal semiregular Klassentyps ist. Weitere Details finden Sie unter CustomizationPointObject .

    Hinweise

    Für einen Lvalue-Bereich e vom Typ T ist ranges :: cbegin ( e ) äquivalent zu

    ranges:: begin ( std:: as_const ( e ) ) .

    		(bis C++23)
    (seit C++23)

    Beispiel

    Diesen Code ausführen 
    #include <cassert>
#include <ranges>
#include <vector>
int main()
{
    std::vector v{3, 1, 4};
    auto vi = std::ranges::cbegin(v);
    assert(3 == *vi);
    ++vi; // OK, constant-iterator object is mutable
    assert(1 == *vi);
    // *vi = 13; // Error: constant-iterator points to an immutable element
    int a[]{3, 1, 4};
    auto ai = std::ranges::cbegin(a); // cbegin works with C-arrays as well
    assert(3 == *ai and *(ai + 1) == 1);
    // *ai = 13; // Error: read-only variable is not assignable
}

    Siehe auch

    (C++20)
    		gibt einen Iterator zum Anfang eines Ranges zurück
    (Anpassungspunktobjekt)
    (C++11) (C++14)
    		gibt einen Iterator zum Anfang eines Containers oder Arrays zurück
    (Funktionstemplate)