CKTIS / C++
std::iterator_traits — types associés aux itérateurs
std::iterator_traits<I>, déclaré dans <iterator>, fournit les types qui décrivent un itérateur, y compris un pointeur brut. Il permet d’écrire des algorithmes indépendants des conteneurs et de distinguer le type de valeur du type produit par le déréférencement.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <iterator>
std::iterator_traits<I>
typename std::iterator_traits<I>::value_typestd::iterator_traits<I> est un modèle de classe de <iterator> qui permet d’obtenir des informations sur le type d’un itérateur à la compilation. Ses membres habituels sont value_type (type de valeur), difference_type (type de différence), reference (type du résultat du déréférencement), pointer (type de pointeur) et iterator_category (catégorie utilisée par les algorithmes classiques).
Pour const int*, value_type est int, tandis que reference est const int& et pointer est const int*. La spécialisation pour les pointeurs vers des objets fournit aussi iterator_concept : il vaut std::contiguous_iterator_tag, alors que iterator_category reste std::random_access_iterator_tag. Ces étiquettes ne sont pas interchangeables.
Le modèle principal utilise les types imbriqués de l’itérateur ou, lorsque certaines exigences sont satisfaites, déduit les informations manquantes. Tous les types ne possèdent pas tous les membres ; certains types d’itérateurs de sortie peuvent avoir des membres de type void. Ne supposez pas non plus que reference désigne toujours une référence ordinaire : il peut s’agir d’un type proxy.
Dans les modèles, typename std::iterator_traits<I>::value_type indique qu’un nom dépendant désigne un type. Dans du code fondé sur les concepts et les ranges, envisagez aussi std::iter_value_t<I>, std::iter_difference_t<I> et std::iter_reference_t<I> ; ce dernier alias découle directement de l’expression de déréférencement, et non du membre reference.
Exemples
#include <iostream>
#include <iterator>
#include <type_traits>
int main() {
const int values[] = {2, 4, 6};
using Traits = std::iterator_traits<const int*>;
static_assert(std::is_same_v<Traits::value_type, int>);
static_assert(std::is_same_v<Traits::reference, const int&>);
static_assert(std::is_same_v<Traits::pointer, const int*>);
static_assert(std::is_same_v<Traits::iterator_category,
std::random_access_iterator_tag>);
static_assert(std::is_same_v<Traits::iterator_concept,
std::contiguous_iterator_tag>);
Traits::value_type sum = 0;
Traits::difference_type count = (values + 3) - values;
for (const int* it = values; it != values + 3; ++it) {
sum += *it;
}
std::cout << sum << ' ' << count << '\n';
}
Résultat
12 3
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.