Partager via

fonctions<ranges>

  • Article

L’en-tête <ranges>C++20 inclut les fonctions d’assistance non membres suivantes.

Fonctions non membres Description
beginC++20 Obtenez un itérateur sur le premier élément de la plage.
cbeginC++20 Obtenez un const itérateur au premier élément de la plage.
cendC++20 Obtenez la sentinelle à la fin de la constplage qualifiée.
cdataC++20 Obtenez un const pointeur vers le premier élément de la plage contiguë.
crbeginC++20 Obtenez un itérateur inverse const au début de la plage.
crendC++20 Obtenez la sentinelle à la fin de ce qui crbegin() retourne.
dataC++20 Obtenez un pointeur vers le premier élément de la plage contiguë.
emptyC++20 Testez si la plage est vide.
endC++20 Obtenez la sentinelle à la fin de la plage.
rbeginC++20 Obtenez un itérateur inverse au début de la plage.
rendC++20 Obtenez un itérateur inverse vers la sentinelle à la fin de la plage.
sizeC++20 Obtenez la taille de la plage en tant que valeur non signée.
ssizeC++20 Obtenez la taille de la plage en tant que valeur signée.

La plupart de ces « fonctions » sont implémentées en tant qu’objets de point de personnalisation. Un objet de point de personnalisation est un objet de fonction qui peut être surchargé sur les types définis par l’utilisateur, tout en appliquant des contraintes sur les types de types pouvant être passés à l’objet de fonction. L’effet net est que le compilateur détermine s’il existe une fonction personnalisée valide à appeler pour le type passé, ou si l’implémentation par défaut doit être utilisée, ou si l’appel est mal formé.

La plupart de ces fonctions ont des fonctions correspondantes dans l’espace std de noms. Mais lorsque vous utilisez des plages, utilisez ces fonctions d’assistance à la place. Ces fonctions utilisent des concepts C++20, qui fournissent de meilleures erreurs de temps de compilation. Étant donné qu’ils sont implémentés en tant que points de personnalisation, les problèmes liés à la recherche dépendante de l’argument (ADL) et la correction const sont évités.

begin

Obtenez un itérateur sur le premier élément de la plage.

template<class T>
constexpr std::input_or_output_iterator auto begin(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Itérateur au premier élément de la plage :

Image d’un vecteur avec les éléments 10, 20 et 30. Le premier élément contient 10 et est intitulé 'begin()'. Le dernier élément contient 30 et est intitulé « dernier élément ». Une zone imaginaire après le dernier élément indique la sentinelle et est étiquetée end().

Si la plage est un tableau, retourne l’équivalent de rg + 0. Si auto(rg.begin()) elle génère un itérateur, retourne l’équivalent de auto(rg.begin()). Si cette expression est mal formée, auto(begin(rg)) elle est utilisée si cette expression génère un itérateur.

Notes

ranges::begin() fonctionne sur toutes les plages, alors que non std::begin() .

Exemple : begin

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto vi = std::ranges::begin(v);
    std::cout << *vi << ' ' << *++vi; // outputs 10 20
}

cbegin

Obtenez un const itérateur sur le premier élément d’une plage. L’itérateur peut accéder aux éléments de la plage, mais ne peut pas les modifier.

template<class T>
constexpr std::input_or_output_iterator auto cbegin(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Itérateur const vers le premier élément de la plage :

Image d’un vecteur avec les éléments 10, 20 et 30. Le premier élément contient 10 et est intitulé « cbegin() ». Le dernier élément contient 30 et est intitulé « dernier élément ». Une zone imaginaire après le dernier élément indique la sentinelle et est étiquetée cend().

Si la plage est un tableau, retourne l’équivalent de rg + 0. Si auto(rg.cbegin()) elle génère un itérateur, retourne l’équivalent de auto(rg.cbegin()). Si cette expression est mal formée, auto(cbegin(rg)) elle est utilisée si cette expression génère un itérateur.

Notes

ranges::cbegin() fonctionne sur toutes les plages, alors que non std::cbegin() .

Exemple : cbegin

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto vi = std::ranges::cbegin(v);
    std::cout << *vi; // outputs 10
    // *vi = 100; // error because the iterator is const
}

cdata

Obtenez un const pointeur vers le premier élément de la plage contiguë.

template<class T>
constexpr std::add_pointer_t<ranges::range_reference_t<const T>> cdata(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Pointeur const , basé sur le type de la plage, vers les premières données d’élément de la plage contiguë. Par exemple, si la plage est un vecteur d’entiers, le type de la valeur de retour est un const int *.

Exemple : cdata

#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    std::string src{ "a string" };
   
    auto c_charPtr = std::ranges::cdata(src); // ptr is a const char *
    auto c_intPtr = std::ranges::cdata(v); // ptr2 is a const int *
    std::cout << c_charPtr << ", " << *c_intPtr << '\n'; // outputs a string, 10

    // *c_intPtr = 100; // error - cannot assign to a const pointer
    // *charPtr = 'A'; // error - cannot assign to a const pointer
}

cend

Obtenez la sentinelle à la fin de la constplage qualifiée. L’itérateur peut accéder aux éléments de la plage, mais ne peut pas les modifier.

template<class T>
constexpr std::sentinel_for<decltype(ranges::cbegin(std::declval<T>()))> auto cend(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Sentinel qui suit le dernier élément de la constplage -qualified :

Image d’un vecteur avec les éléments 10, 20 et 30. Le premier élément contient 10 et est étiqueté cbegin(). Le dernier élément contient 30 et est intitulé « dernier élément ». Une zone imaginaire après le dernier élément indique la sentinelle et est étiquetée cend().

Notes

ranges::cend() fonctionne sur toutes les plages, alors que non std::cend() .

Exemple : cend

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto i = std::ranges::cend(v);
    --i; // get off the sentinel and onto the last element in the range
    std::cout << *i; // outputs 30
    // *i = 300 // error because the iterator is const
}

crbegin

Obtenez un itérateur inverse const sur le premier élément d’une plage inversée. Un itérateur inverse retourne les éléments de la plage dans l’ordre inverse. La plage elle-même n’est pas inversée ; l’accès à celui-ci est.

template<class T>
constexpr std::input_or_output_iterator auto crbegin(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Itérateur inverse const au premier élément de la plage. Cet itérateur retourne les éléments de la plage dans l’ordre inverse, en commençant à la fin de la plage :

Image d’un vecteur contenant les éléments 10, 20 et 30. Il existe une zone imaginaire avant l’élément le plus à gauche (l’élément le plus à gauche contient le nombre 10) qui représente la sentinelle. C’est étiqueté crend(). Le premier élément du vecteur contient le nombre 10 et est intitulé « dernier élément ». L’élément le plus à droite du vecteur contient 30 et est étiqueté crbegin().

Si la plage est un tableau, retourne l’équivalent d’où reverse_iterator{rg + n} n correspond le nombre d’éléments du tableau. Si auto(rg.crbegin()) elle génère un itérateur, retourne l’équivalent de auto(rg.crbegin()). Si cette expression est mal formée, auto(crbegin(rg)) elle est utilisée si cette expression génère un itérateur.

Notes

ranges::crbegin() fonctionne sur toutes les plages bidirectionnelles, alors que non std::crbegin() .

Exemple : crbegin

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::crbegin(v);
    std::cout << *vi << ' ' << *++vi << ' ' << *++vi; // outputs 30 20 10
    // vi[1] = 100; // error because the iterator is const
}

crend

Obtenez la sentinelle à la fin de ce qui crbegin() retourne. Un itérateur inverse retourne les éléments de la plage dans l’ordre inverse. La plage elle-même n’est pas inversée ; l’accès à celui-ci est.

template<class T>
std::sentinel_for<decltype(ranges::crbegin(declval<T>()))> auto crend(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Sentinelle à la fin de ce qui cbegin() retourne. La sentinelle suit le dernier élément dans une vue inversée de la plage :

Image d’un vecteur contenant les éléments 10, 20 et 30. Il existe une zone imaginaire avant l’élément le plus à gauche (l’élément le plus à gauche contient le nombre 10) qui représente la sentinelle. C’est étiqueté crend(). Le premier élément du vecteur contient le nombre 10 et est intitulé « dernier élément ». L’élément le plus à droite du vecteur contient 30 et est étiqueté crbegin().

Notes

ranges::crend() fonctionne sur toutes les plages bidirectionnelles, alors que non std::crend() .

Exemple crend

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::crend(v);
    --vi; // get off the sentinel and onto the last element in the reversed range
    std::cout << *vi; // outputs 10
    // vi[0] = 300; // error because the iterator is const    
    std::cout << *vi << ' ' << *--vi << ' ' << *--vi; // outputs 10, 20, 30
}

data

Obtenez un pointeur vers le premier élément d’une plage contiguë.

template<class T>
constexpr std::add_pointer_t<ranges::range_reference_t<T>> data(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Pointeur, basé sur le type de la plage, vers le premier élément de la plage contiguë. Par exemple, si la plage est un vecteur d’entiers, le type de la valeur de retour est un int *.

Exemple

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    std::string src{ "a string" };
   
    auto charPtr = std::ranges::data(src); // charPtr is a char *
    auto intPtr = std::ranges::data(v); // intPtr is an int *
    std::cout << charPtr << ", " << *intPtr << '\n'; // outputs a string, 10
    *intPtr = 100;
    *charPtr = 'A';
    std::cout << charPtr << ", " << *intPtr; // outputs A string, 100
}

empty

Testez si la plage est vide.

template<class T>
constexpr bool empty(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Retourne true si la plage n’a aucun élément ; sinon false.

Exemple

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
        std::vector v{10,20,30};
    std::vector<int> v2;

    std::cout << std::boolalpha << std::ranges::empty(v); // outputs false
    std::cout << std::boolalpha << ", " << std::ranges::empty(v2); // outputs true
}

end

Obtenez la sentinelle à la fin de la plage.

template<class T>
std::sentinel_for<ranges::iterator_t<T>> auto end(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Sentinel qui suit le dernier élément de la plage :

Image d’un vecteur avec les éléments 10, 20 et 30. Le premier élément contient 10 et est étiqueté begin(). Le dernier élément contient 30 et est intitulé « dernier élément ». Une zone imaginaire après le dernier élément indique la sentinelle et est étiquetée end().

Notes

ranges::end() fonctionne sur toutes les plages, alors que non std::end() .

Exemple

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto i = std::ranges::end(v);
    --i; // get off the sentinel and onto the last element in the range
    std::cout << *i; // outputs 30
}

rbegin

Obtenez un itérateur inverse sur le premier élément d’une plage inversée. Un itérateur inverse retourne les éléments de la plage dans l’ordre inverse. La plage elle-même n’est pas inversée ; l’accès à celui-ci est.

template<class T>
constexpr std::input_or_output_iterator auto rbegin(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Itérateur inverse au premier élément de la plage. Cet itérateur retourne les éléments de la plage dans l’ordre inverse, en commençant à la fin de la plage inversée :

Image d’un vecteur contenant les éléments 10, 20 et 30. Il existe une zone imaginaire avant l’élément le plus à gauche (l’élément le plus à gauche contient le nombre 10) qui représente la sentinelle. Elle est étiquetée rend(). Le premier élément du vecteur contient le nombre 10 et est intitulé « dernier élément ». L’élément le plus à droite du vecteur contient 30 et est étiqueté rbegin().

Si la plage est un tableau, retourne l’équivalent d’où reverse_iterator{rg + n} n correspond le nombre d’éléments du tableau. Si auto(rg.rbegin()) elle génère un itérateur, retourne l’équivalent de auto(rg.rbegin()). Si cette expression est mal formée, auto(rbegin(rg)) elle est utilisée si cette expression génère un itérateur.

Notes

ranges::rbegin() fonctionne sur toutes les plages bidirectionnelles, alors que non std::rbegin() .

Exemple

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::rbegin(v);
    std::cout << *vi << ' ' << *++vi << ' ' << *++vi; // outputs 30 20 10
}

rend

Obtenez un itérateur inverse vers la sentinelle à la fin d’une vue inversée de la plage. Un itérateur inverse retourne les éléments de la plage dans l’ordre inverse. La plage elle-même n’est pas inversée ; l’accès à celui-ci est.

template<class T>
constexpr 
std::sentinel_for<decltype(ranges::rbegin(std::declval<T>()))> auto rend(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Itérateur inverse vers la sentinelle à la fin de la plage. La sentinelle suit le dernier élément dans une vue inversée de la plage :

Image d’un vecteur contenant les éléments 10, 20 et 30. Il existe une zone imaginaire avant l’élément le plus à gauche (l’élément le plus à gauche contient le nombre 10) qui représente la sentinelle. Elle est étiquetée rend(). Le premier élément du vecteur contient le nombre 10 et est intitulé « dernier élément ». L’élément le plus à droite du vecteur contient 30 et est étiqueté rbegin().

Notes

ranges::rend() fonctionne sur toutes les plages bidirectionnelles, alors que non std::rend() .

Exemple

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::rend(v);
    --vi; // get off the sentinel and onto the last element in the reversed range
    std::cout << *vi; // outputs 10
    std::cout << *vi << ' ' << *--vi << ' ' << *--vi; // outputs 10, 20, 30
}

size

Obtenez le nombre d’éléments de la plage sous forme de valeur non signée.

template<class T>
constexpr /*unsigned integer-like type */ size(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Nombre d’éléments de la plage sous forme de valeur entière non signée.

Notes

Cette fonction s’exécute en temps constant.

Exemple

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto s = std::ranges::size(v); // s is a size_t
    std::cout << s; // outputs 3
}

ssize

Obtenez la taille de la plage en tant que valeur signée.

template<class T>
constexpr /* signed-integer-like type */ ssize(T&& rg);

Paramètres

T
Type de la plage.

rg
Plage.

Valeur retournée

Nombre d’éléments de la plage sous la forme d’une valeur de type entier signé.

Notes

Cette fonction s’exécute en temps constant.

Exemple

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto s = std::ranges::ssize(v);
    std::cout << s; // outputs 3
}

Voir aussi

<ranges>
Qu’est-ce que les objets de personnalisation