Namespaces
Variants

std:: iterator_traits

From cppreference.net
C++
Iterator library
Iterator concepts
Iterator primitives
(deprecated in C++17)
iterator_traits
(C++20)
(C++20)


Algorithm concepts and utilities
Indirect callable concepts
Common algorithm requirements
(C++20)
(C++20)
(C++20)
Utilities
(C++20)
Iterator adaptors
Range access
(C++11) (C++14)
(C++14) (C++14)
(C++11) (C++14)
(C++14) (C++14)
(C++17) (C++20)
(C++17)
(C++17)
Défini dans l'en-tête <iterator>
template < class Iter >
struct iterator_traits ;
template < class T >
struct iterator_traits < T * > ;
template < class T >
struct iterator_traits < const T * > ;
(supprimé en C++20)

std::iterator_traits est la classe de traits de type qui fournit une interface uniforme pour les propriétés des types LegacyIterator . Cela permet de mettre en œuvre des algorithmes uniquement en termes d'itérateurs.

Le modèle peut être spécialisé pour les itérateurs définis par l'utilisateur afin que les informations sur l'itérateur puissent être récupérées même si le type ne fournit pas les typedefs habituels.

Les spécialisations utilisateur peuvent définir le type imbriqué iterator_concept à l'un des tags de catégorie d'itérateur , pour indiquer la conformité aux concepts d'itérateur.

(depuis C++20)

Table des matières

Paramètres du modèle

Iter - le type d'itérateur pour récupérer les propriétés

Types membres

Type imbriqué Définition
difference_type Iter::difference_type
value_type Iter::value_type
pointer Iter::pointer
reference Iter::reference
iterator_category Iter::iterator_category


Si Iter ne possède aucun des cinq types imbriqués ci-dessus, alors ce modèle n'a aucun membre portant ces noms ( std::iterator_traits est compatible SFINAE).

(depuis C++17)
(jusqu'à C++20)

Si Iter ne possède pas pointer , mais possède les quatre autres types imbriqués, alors ces quatre types imbriqués sont déclarés comme suit :

Type imbriqué Définition
difference_type Iter::difference_type
value_type Iter::value_type
pointer void
reference Iter::reference
iterator_category Iter::iterator_category


Sinon, si Iter satisfait le concept d'exposition uniquement __LegacyInputIterator , les types imbriqués sont déclarés comme suit :

Type imbriqué Définition
difference_type std:: incrementable_traits < Iter > :: difference_type
value_type std:: indirectly_readable_traits < Iter > :: value_type
pointer
  • Iter::pointer si valide.
  • Sinon decltype ( std:: declval < Iter & > ( ) . operator - > ( ) ) si valide.
  • Sinon void .
reference
iterator_category


Sinon, si Iter satisfait le concept d'exposition uniquement __LegacyIterator , les types imbriqués sont déclarés comme suit :

Type imbriqué Définition
difference_type
value_type void
pointer void
reference void
iterator_category std::output_iterator_tag

Sinon, ce modèle n'a aucun membre portant ces noms ( std::iterator_traits est compatible SFINAE).

(depuis C++20)

Spécialisations

Ce trait de type peut être spécialisé pour les types fournis par l'utilisateur qui peuvent être utilisés comme itérateurs. La bibliothèque standard fournit des spécialisations partielles pour les types pointeur T* , ce qui permet d'utiliser tous les algorithmes basés sur les itérateurs avec les pointeurs bruts.

La bibliothèque standard fournit également des spécialisations partielles pour certains adaptateurs d'itérateurs standard.

(since C++20)

T* spécialisation des types imbriqués

Seulement spécialisé si std:: is_object_v < T > est true .

(depuis C++20)


Type imbriqué Définition
difference_type std::ptrdiff_t
value_type T (jusqu'en C++20) std:: remove_cv_t < T > (depuis C++20)
pointer T*
reference T&
iterator_category std::random_access_iterator_tag
iterator_concept (depuis C++20) std::contiguous_iterator_tag


const T * types imbriqués de la spécialisation

Type imbriqué Définition
difference_type std::ptrdiff_t
value_type T
pointer const T *
reference const T &
iterator_category std::random_access_iterator_tag
(jusqu'en C++20)

Spécialisations pour les types de bibliothèque

(C++20)
fournit une interface uniforme pour les propriétés du type std::common_iterator
(spécialisation de modèle de classe)
(C++20)
fournit une interface uniforme pour les propriétés du type std::counted_iterator
(spécialisation de modèle de classe)

Exemple

Montre une implémentation à usage général de std:: reverse ( ) pour les itérateurs bidirectionnels.

Exécuter ce code 
#include <iostream>
#include <iterator>
#include <list>
#include <vector>
template<class BidirIt>
void my_reverse(BidirIt first, BidirIt last)
{
    typename std::iterator_traits<BidirIt>::difference_type n = std::distance(first, last);
    for (--n; n > 0; n -= 2)
    {
        typename std::iterator_traits<BidirIt>::value_type tmp = *first;
        *first++ = *--last;
        *last = tmp;
    }
}
int main()
{
    std::vector<int> v{1, 2, 3, 4, 5};
    my_reverse(v.begin(), v.end());
    for (int n : v)
        std::cout << n << ' ';
    std::cout << '\n';
    std::list<int> l{1, 2, 3, 4, 5};
    my_reverse(l.begin(), l.end());
    for (int n : l)
        std::cout << n << ' ';
    std::cout << '\n';
    int a[]{1, 2, 3, 4, 5};
    my_reverse(a, a + std::size(a));
    for (int n : a)
        std::cout << n << ' ';
    std::cout << '\n';
//  std::istreambuf_iterator<char> i1(std::cin), i2;
//  my_reverse(i1, i2); // compilation error: i1, i2 are input iterators
}

Sortie : 

5 4 3 2 1
5 4 3 2 1
5 4 3 2 1

Voir aussi

(obsolète en C++17)
classe de base pour faciliter la définition des types requis pour les itérateurs simples
(modèle de classe)
(C++20)
types de classes vides utilisés pour indiquer les catégories d'itérateurs
(classe)
(C++20) (C++20) (C++23) (C++20) (C++20) (C++20)
calcule les types associés d'un itérateur
(modèle d'alias)