Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

std::iterator_traits — tipi associati all’iteratore

std::iterator_traits<I>, dichiarato in <iterator>, fornisce tipi che descrivono un iteratore, compreso un puntatore semplice. Consente di scrivere algoritmi indipendenti dal contenitore e di distinguere il tipo del valore dal tipo prodotto dalla dereferenziazione.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

#include <iterator>
std::iterator_traits<I>
typename std::iterator_traits<I>::value_type

std::iterator_traits<I> è un modello di classe di <iterator> che permette di ottenere informazioni sul tipo di un iteratore in fase di compilazione. I membri tipici sono value_type (tipo del valore), difference_type (tipo della differenza), reference (tipo del risultato della dereferenziazione), pointer (tipo di puntatore) e iterator_category (categoria per gli algoritmi classici).

Per const int*, value_type è int, mentre reference è const int& e pointer è const int*. La specializzazione per i puntatori a oggetti fornisce anche iterator_concept: è std::contiguous_iterator_tag, sebbene iterator_category resti std::random_access_iterator_tag. Questi tag non sono intercambiabili.

Il modello primario usa i tipi annidati dell’iteratore oppure, se sono soddisfatti determinati requisiti, deduce le informazioni mancanti. Non tutti i tipi hanno tutti i membri; alcuni tipi di iteratori di output possono avere membri di tipo void. Inoltre, non dare per scontato che reference indichi sempre un riferimento ordinario: può essere un tipo proxy.

Nei modelli, typename std::iterator_traits<I>::value_type indica che un nome dipendente rappresenta un tipo. Nel codice basato su concepts e ranges, considera anche std::iter_value_t<I>, std::iter_difference_t<I> e std::iter_reference_t<I>; quest’ultimo alias deriva direttamente dall’espressione di dereferenziazione, non dal membro reference.

Esempi

#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';
}

Risultato

12 3

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti