fonctions<ranges>
L’en-tête <ranges>
C++20 inclut les fonctions d’assistance non membres suivantes.
Fonctions non membres | Description |
---|---|
begin C++20 |
Obtenez un itérateur sur le premier élément de la plage. |
cbegin C++20 |
Obtenez un const itérateur au premier élément de la plage. |
cend C++20 |
Obtenez la sentinelle à la fin de la const plage qualifiée. |
cdata C++20 |
Obtenez un const pointeur vers le premier élément de la plage contiguë. |
crbegin C++20 |
Obtenez un itérateur inverse const au début de la plage. |
crend C++20 |
Obtenez la sentinelle à la fin de ce qui crbegin() retourne. |
data C++20 |
Obtenez un pointeur vers le premier élément de la plage contiguë. |
empty C++20 |
Testez si la plage est vide. |
end C++20 |
Obtenez la sentinelle à la fin de la plage. |
rbegin C++20 |
Obtenez un itérateur inverse au début de la plage. |
rend C++20 |
Obtenez un itérateur inverse vers la sentinelle à la fin de la plage. |
size C++20 |
Obtenez la taille de la plage en tant que valeur non signée. |
ssize C++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 :
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 :
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 const
plage 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 const
plage -qualified :
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 :
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 :
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 :
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 :
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 :
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
}