std::ranges::begin

inline namespace /* unspecified */ {
    inline constexpr /* unspecified */ begin = /* unspecified */;
}

template< class T >
    requires /* see below */
constexpr std::input_or_output_iterator auto begin( T&& t );

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

Si l'argument est une lvalue ou ranges::enable_borrowed_range<std::remove_cv_t<T>> est true, alors un appel à ranges::begin est expression-équivalente à :

1. t + 0 si t a un type tableau.
   • Si std::remove_all_extents_t<std::remove_reference_t<T>> est incomplet, alors l'appel à ranges::begin est mal formé, aucun diagnostic requis.
2. Sinon, decay-copy(t.begin())(jusqu'à C++23)auto(t.begin())(depuis C++23), si cette expression est valide et que son type modélise std::input_or_output_iterator.
3. Sinon, decay-copy(begin(t))(jusqu'à C++23)auto(begin(t))(depuis C++23), si T est un type classe ou énumération, que cette expression est valide et que son type modélise std::input_or_output_iterator, où la signification de begin est établie comme si en effectuant la recherche dépendante des arguments seulement.

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

Objets de point de personnalisation

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

Notes

Si l'argument est une rvalue (c'est-à-dire T est un type objet) et ranges:: enable_borrowed_range < std:: remove_cv_t < T >> est false , l'appel à ranges::begin est mal formé, ce qui entraîne également un échec de substitution.

Le type de retour modélise std::input_or_output_iterator dans tous les cas.

La norme C++20 exige que si l'appel de fonction sous-jacent begin retourne une prvalue, la valeur de retour est construite par déplacement à partir de l'objet temporaire matérialisé. Toutes les implémentations retournent directement la prvalue à la place. L'exigence est corrigée par la proposition post-C++20 P0849R8 pour correspondre aux implémentations.

Exemple

#include <cassert>
#include <ranges>
#include <vector>
int main() 
{
    std::vector v{3, 1, 4};
    auto vi = std::ranges::begin(v);
    auto vci = std::ranges::cbegin(v);
    assert(*vi == 3 and *vi == *vci);
    ++vi;
    ++vci; // OK : vci est un objet modifiable
    *vi = 42; // OK : vi pointe vers un élément mutable
    // *vci = 13; // Erreur : vci pointe vers un élément immuable
    int a[]{-5, 10, 15};
    auto ai = std::ranges::begin(a); // fonctionne également avec les tableaux C
    assert(*ai == -5);
    *ai = 42; // OK
}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi