Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

std::iterator_traits — tipos associados ao iterador

std::iterator_traits<I>, declarado em <iterator>, disponibiliza tipos que descrevem um iterador, incluindo um ponteiro simples. Permite escrever algoritmos independentes do contentor e distinguir o tipo do valor do tipo produzido pela desreferenciação.

Versão: C++23; repository compiler flag, production runtime not attested

Sintaxe

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

std::iterator_traits<I> é um modelo de classe de <iterator> que permite obter informações sobre o tipo de um iterador em tempo de compilação. Os membros habituais são value_type (tipo do valor), difference_type (tipo da diferença), reference (tipo do resultado da desreferenciação), pointer (tipo de ponteiro) e iterator_category (categoria para algoritmos clássicos).

Para const int*, value_type é int, enquanto reference é const int& e pointer é const int*. A especialização para ponteiros para objetos também disponibiliza iterator_concept: é std::contiguous_iterator_tag, embora iterator_category continue a ser std::random_access_iterator_tag. Estas etiquetas não são intercambiáveis.

O modelo principal utiliza os tipos aninhados do iterador ou, quando determinados requisitos são cumpridos, deduz as informações em falta. Nem todos os tipos têm todos os membros; alguns tipos de iteradores de saída podem ter membros de tipo void. Também não pressuponha que reference designa sempre uma referência normal — pode ser um tipo proxy.

Em modelos, typename std::iterator_traits<I>::value_type indica que um nome dependente designa um tipo. Em código baseado em concepts e ranges, considere também std::iter_value_t<I>, std::iter_difference_t<I> e std::iter_reference_t<I>; este último alias decorre diretamente da expressão de desreferenciação, e não do membro reference.

Exemplos

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

Resultado

12 3

O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.

Fontes