Namespaces
Variants

std::ranges:: cbegin

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 */ cbegin = /* unspecified */ ;

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

requires /* voir ci-dessous */

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

Retourne un itérateur vers le premier élément de l'argument qualifié const.

(until C++23)

Retourne un itérateur constant vers le premier élément de l'argument.

(since C++23)

range-begin-end.svg

Soit CT défini comme

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

Un appel à ranges::cbegin est expression-équivalent à ranges:: begin ( 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::cbegin est expression-équivalent à :

Dans tous les autres cas, un appel à ranges::cbegin 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 template.

(depuis C++23)

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

Table des matières

Objets de point de personnalisation

Le nom ranges::cbegin 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.

Notes

Pour une plage lvalue e de type T , ranges :: cbegin ( e ) est équivalent à

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

(jusqu'à C++23)
(depuis C++23)

Exemple

Exécuter ce code 
#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, l'objet itérateur constant est mutable
    assert(1 == *vi);
    // *vi = 13; // Erreur : l'itérateur constant pointe vers un élément immuable
    int a[]{3, 1, 4};
    auto ai = std::ranges::cbegin(a); // cbegin fonctionne également avec les tableaux C
    assert(3 == *ai and *(ai + 1) == 1);
    // *ai = 13; // Erreur : variable en lecture seule non assignable
}

Voir aussi

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