KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

std::iterator_traits — iteratorgerelateerde typen

std::iterator_traits<I> uit <iterator> biedt typen die een iterator beschrijven, ook een gewone pointer. Hiermee schrijf je algoritmen die niet van een bepaalde container afhangen en onderscheid je het waardetype van het type dat derefereren oplevert.

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

Syntax

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

std::iterator_traits<I> is een class template uit <iterator> waarmee je tijdens het compileren informatie over een iteratortype kunt opvragen. Gebruikelijke members zijn value_type (waardetype), difference_type (verschiltype), reference (type van het dereferentieresultaat), pointer (pointertype) en iterator_category (categorie voor klassieke algoritmen).

Voor const int* is value_type gelijk aan int, terwijl reference const int& en pointer const int* is. De specialisatie voor pointers naar objecten biedt ook iterator_concept: dat is std::contiguous_iterator_tag, hoewel iterator_category std::random_access_iterator_tag blijft. Deze tags zijn niet onderling uitwisselbaar.

De primaire template gebruikt de geneste typen van een iterator of leidt ontbrekende informatie af wanneer aan bepaalde vereisten is voldaan. Niet elk type heeft alle members; sommige typen output-iterators kunnen members van het type void hebben. Ga er ook niet van uit dat reference altijd een gewone referentie aanduidt: het kan een proxytype zijn.

In templates geeft typename std::iterator_traits<I>::value_type aan dat een afhankelijke naam een type aanduidt. Overweeg in code op basis van concepts en ranges ook std::iter_value_t<I>, std::iter_difference_t<I> en std::iter_reference_t<I>; de laatste alias volgt rechtstreeks uit de dereferentie-expressie en niet uit de member reference.

Voorbeelden

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

Resultaat

12 3

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen