Namespaces
Variants

std::ranges:: crbegin

From cppreference.net
C++
Ranges library
Range adaptors
Défini dans l'en-tête <ranges>
Défini dans l'en-tête <iterator>
inline namespace /* unspecified */ {

inline constexpr /* unspecified */ crbegin = /* unspecified */ ;

}
(depuis C++20)
(objet de point de personnalisation)
Signature d'appel
template < class T >

requires /* voir ci-dessous */

constexpr /* voir ci-dessous */ auto crbegin ( T && t ) ;
(depuis C++20)

Retourne un itérateur vers le premier élément de l'argument qualifié const qui est traité comme une séquence inversée.

(until C++23)

Retourne un itérateur constant vers le premier élément de l'argument qui est traité comme une séquence inversée.

(since C++23)

range-rbegin-rend.svg

Soit CT défini comme

  • const std:: remove_reference_t < T > & si l'argument est une lvalue (c'est-à-dire si T est un type référence lvalue),
  • const T sinon.

Un appel à ranges::crbegin est équivalent en expression à ranges:: rbegin ( static_cast < CT && > ( t ) ) .

(jusqu'à C++23)

Si l'argument est une lvalue ou que ranges:: enable_borrowed_range < std:: remove_cv_t < T >> est true , alors un appel à ranges::crbegin est équivalent en expression à :

Dans tous les autres cas, un appel à ranges::crbegin est mal formé, ce qui peut entraîner une échec de substitution lorsque l'appel apparaît dans le contexte immédiat d'une instanciation de modèle.

(depuis C++23)

Le type de retour modélise std::input_or_output_iterator et constant-iterator (depuis C++23) dans tous les cas.

Objets de point de personnalisation

Le nom ranges::crbegin désigne un objet de point de personnalisation , qui est un objet fonction const d'un type de classe littéral semiregular . Voir CustomizationPointObject pour plus de détails.

Exemple

Exécuter ce code 
#include <cassert>
#include <iterator>
#include <span>
#include <vector>
int main()
{
    std::vector<int> v{3, 1, 4};
    auto vi = std::ranges::crbegin(v);
    assert(*vi == 4);
    ++vi; // OK, l'objet itérateur est mutable
    assert(*vi == 1);
    // *vi = 13; // Erreur : l'élément sous-jacent est en lecture seule
    int a[]{-5, 10, 15};
    auto ai = std::ranges::crbegin(a);
    assert(*ai == 15);
    // auto x_x = std::ranges::crbegin(std::vector<int>{6, 6, 6});
    // mal formé : l'argument est une rvalue (voir Notes ↑)
    auto si = std::ranges::crbegin(std::span{a}); // OK
    assert(*si == 15);
    static_assert
    (
        std::ranges::enable_borrowed_range<std::remove_cv_t<decltype(std::span{a})>>
    );
}

Voir aussi

(C++20)
retourne un itérateur inverse vers un intervalle
(objet de point de personnalisation)
(C++14)
retourne un itérateur inverse vers le début d'un conteneur ou d'un tableau
(fonction template)