Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Range e viste

Un range espone gli elementi tramite un iteratore iniziale e un sentinella finale. Una vista è un range con requisiti aggiuntivi che la rendono utile per costruire pipeline. Gli adattatori std::views::filter e std::views::transform selezionano e trasformano gli elementi senza creare un contenitore intermedio dei risultati.

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

Sintassi

auto result = range | std::views::filter(predicate) | std::views::transform(function);

Un range che soddisfa std::ranges::range fornisce std::ranges::begin(r) e std::ranges::end(r). La prima espressione restituisce un iteratore, la seconda un sentinella finale; i loro tipi non devono essere identici. Un range non deve necessariamente essere un contenitore o memorizzare elementi.

Una vista che soddisfa std::ranges::view è un range spostabile, riconosciuto tramite enable_view, con requisiti aggiuntivi sulla complessità delle operazioni: in particolare, la costruzione per spostamento è O(1), così come quella per copia quando è disponibile. Una vista non deve necessariamente essere copiabile. Vista non significa neppure non proprietaria: alcune viste possiedono dati, mentre altre vi fanno soltanto riferimento.

L’header <ranges> fornisce gli adattatori. r | std::views::filter(pred) seleziona gli elementi che soddisfano pred, mentre aggiungendo | std::views::transform(fn) si trasformano i valori selezionati. Questa pipeline è lazy: non crea un contenitore intermedio dei risultati; la ricerca e la trasformazione avvengono durante l’iterazione. Nell’esempio, result produce i quadrati degli elementi pari di numbers, cioè 4 16 36.

Qui la vista fa riferimento a numbers, quindi l’array deve rimanere in vita per tutta la durata del suo utilizzo. Non restituire da una funzione una pipeline di questo tipo che faccia riferimento a un array locale. La valutazione lazy non significa che tutti i risultati vengano memorizzati: un altro passaggio può invocare di nuovo le funzioni, quindi qui usa funzioni prive di effetti collaterali.

L’esempio è pensato per essere compilato con -std=c++23; il comportamento in esecuzione in produzione non è attestato. Il documento fornito è una bozza di lavoro in evoluzione, non una pubblicazione C++23 definitiva; non dare per scontato che tutte le API attualmente presenti vi appartengano.

Esempi

#include <array>
#include <iostream>
#include <ranges>

int main() {
    std::array<int, 6> numbers{1, 2, 3, 4, 5, 6};
    auto result = numbers
        | std::views::filter([](int n) { return n % 2 == 0; })
        | std::views::transform([](int n) { return n * n; });

    bool first = true;
    for (int value : result) {
        if (!first) {
            std::cout << ' ';
        }
        first = false;
        std::cout << value;
    }
    std::cout << '\n';
}

Risultato

4 16 36

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