Condividi tramite

<ranges> funzioni

  • Articolo

L'intestazione <ranges>C++20 include le funzioni helper non membro seguenti.

Funzioni non membro Descrizione
beginC++20 Ottenere un iteratore al primo elemento dell'intervallo.
cbeginC++20 Ottenere un const iteratore al primo elemento dell'intervallo.
cendC++20 Ottenere la sentinella alla fine dell'intervallo constqualificato.
cdataC++20 Ottenere un const puntatore al primo elemento nell'intervallo contiguo.
crbeginC++20 Ottiene un iteratore inverso const all'inizio dell'intervallo.
crendC++20 Ottenere l'sentinel alla fine di ciò che crbegin() restituisce.
dataC++20 Ottenere un puntatore al primo elemento nell'intervallo contiguo.
emptyC++20 Verificare se l'intervallo è vuoto.
endC++20 Ottenere la sentinella alla fine dell'intervallo.
rbeginC++20 Ottiene un iteratore inverso all'inizio dell'intervallo.
rendC++20 Ottenere un iteratore inverso alla sentinella alla fine dell'intervallo.
sizeC++20 Ottenere le dimensioni dell'intervallo come valore senza segno.
ssizeC++20 Ottenere le dimensioni dell'intervallo come valore con segno.

Molte di queste "funzioni" vengono implementate come oggetti punto di personalizzazione. Un oggetto punto di personalizzazione è un oggetto funzione che può essere sottoposto a overload sui tipi definiti dall'utente, applicando al tempo stesso vincoli su quali tipi di tipi possono essere passati all'oggetto funzione. L'effetto netto è che il compilatore individua se è presente una funzione personalizzata valida da chiamare per il tipo passato o se l'implementazione predefinita deve essere usata o se la chiamata non è corretta.

Molte di queste funzioni hanno funzioni corrispondenti nello spazio dei std nomi . Ma quando si usano gli intervalli, usare invece queste funzioni helper. Queste funzioni usano i concetti di C++20, che offrono errori di compilazione migliori. Poiché vengono implementati come punti di personalizzazione, vengono evitati i problemi correlati alla ricerca dipendente dall'argomento (ADL) e alla correttezza const.

begin

Ottenere un iteratore al primo elemento dell'intervallo.

template<class T>
constexpr std::input_or_output_iterator auto begin(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Iteratore al primo elemento dell'intervallo:

Immagine di un vettore con gli elementi 10, 20 e 30. Il primo elemento contiene 10 e viene etichettato

Se l'intervallo è una matrice, restituisce l'equivalente di rg + 0. Se auto(rg.begin()) restituisce un iteratore, restituisce l'equivalente di auto(rg.begin()). Se tale espressione non è formata correttamente, auto(begin(rg)) viene utilizzata se tale espressione restituisce un iteratore.

Osservazioni:

ranges::begin() funziona su tutti gli intervalli, mentre std::begin() non può.

Esempio: begin

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto vi = std::ranges::begin(v);
    std::cout << *vi << ' ' << *++vi; // outputs 10 20
}

cbegin

Ottenere un const iteratore al primo elemento di un intervallo. L'iteratore può accedere agli elementi nell'intervallo, ma non può modificarli.

template<class T>
constexpr std::input_or_output_iterator auto cbegin(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Iteratore const al primo elemento dell'intervallo:

Immagine di un vettore con gli elementi 10, 20 e 30. Il primo elemento contiene 10 e viene etichettato come

Se l'intervallo è una matrice, restituisce l'equivalente di rg + 0. Se auto(rg.cbegin()) restituisce un iteratore, restituisce l'equivalente di auto(rg.cbegin()). Se tale espressione non è formata correttamente, auto(cbegin(rg)) viene utilizzata se tale espressione restituisce un iteratore.

Osservazioni:

ranges::cbegin() funziona su tutti gli intervalli, mentre std::cbegin() non può.

Esempio: cbegin

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto vi = std::ranges::cbegin(v);
    std::cout << *vi; // outputs 10
    // *vi = 100; // error because the iterator is const
}

cdata

Ottenere un const puntatore al primo elemento nell'intervallo contiguo.

template<class T>
constexpr std::add_pointer_t<ranges::range_reference_t<const T>> cdata(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Puntatore const , in base al tipo dell'intervallo, ai primi dati dell'elemento nell'intervallo contiguo. Ad esempio, se l'intervallo è un vettore di numeri interi, il tipo del valore restituito è .const int *

Esempio: cdata

#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    std::string src{ "a string" };
   
    auto c_charPtr = std::ranges::cdata(src); // ptr is a const char *
    auto c_intPtr = std::ranges::cdata(v); // ptr2 is a const int *
    std::cout << c_charPtr << ", " << *c_intPtr << '\n'; // outputs a string, 10

    // *c_intPtr = 100; // error - cannot assign to a const pointer
    // *charPtr = 'A'; // error - cannot assign to a const pointer
}

cend

Ottenere la sentinella alla fine dell'intervallo constqualificato. L'iteratore può accedere agli elementi nell'intervallo, ma non può modificarli.

template<class T>
constexpr std::sentinel_for<decltype(ranges::cbegin(std::declval<T>()))> auto cend(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Sentinel che segue l'ultimo elemento nell'intervallo constqualificato:

Immagine di un vettore con gli elementi 10, 20 e 30. Il primo elemento contiene 10 ed è etichettato cbegin(). L'ultimo elemento contiene 30 e viene etichettato come 'ultimo elemento'. Una casella immaginaria dopo l'ultimo elemento indica la sentinella e viene etichettata cend().

Osservazioni:

ranges::cend() funziona su tutti gli intervalli, mentre std::cend() non può.

Esempio: cend

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto i = std::ranges::cend(v);
    --i; // get off the sentinel and onto the last element in the range
    std::cout << *i; // outputs 30
    // *i = 300 // error because the iterator is const
}

crbegin

Ottiene un iteratore inverso const al primo elemento in un intervallo invertito. Un iteratore inverso restituisce gli elementi dell'intervallo in ordine inverso. L'intervallo stesso non è invertito; è possibile accedervi.

template<class T>
constexpr std::input_or_output_iterator auto crbegin(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Iteratore inverso const al primo elemento dell'intervallo. Questo iteratore restituisce gli elementi dell'intervallo in ordine inverso, a partire dalla fine dell'intervallo:

Immagine di un vettore contenente gli elementi 10, 20 e 30. C'è una casella immaginaria prima dell'elemento più a sinistra (l'elemento più a sinistra contiene il numero 10) che rappresenta la sentinella. È etichettato crend(). Il primo elemento nel vettore contiene il numero 10 ed è etichettato come 'ultimo elemento'. L'elemento più a destra nel vettore contiene 30 ed è etichettato crbegin().

Se l'intervallo è una matrice, restituisce l'equivalente di reverse_iterator{rg + n} dove n è il numero di elementi nella matrice. Se auto(rg.crbegin()) restituisce un iteratore, restituisce l'equivalente di auto(rg.crbegin()). Se tale espressione non è formata correttamente, auto(crbegin(rg)) viene utilizzata se tale espressione restituisce un iteratore.

Osservazioni:

ranges::crbegin() funziona su tutti gli intervalli bidirezionali, mentre std::crbegin() non può.

Esempio: crbegin

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::crbegin(v);
    std::cout << *vi << ' ' << *++vi << ' ' << *++vi; // outputs 30 20 10
    // vi[1] = 100; // error because the iterator is const
}

crend

Ottenere l'sentinel alla fine di ciò che crbegin() restituisce. Un iteratore inverso restituisce gli elementi dell'intervallo in ordine inverso. L'intervallo stesso non è invertito; è possibile accedervi.

template<class T>
std::sentinel_for<decltype(ranges::crbegin(declval<T>()))> auto crend(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Sentinel alla fine di ciò che cbegin() restituisce. Sentinel segue l'ultimo elemento in una visualizzazione invertita dell'intervallo:

Immagine di un vettore contenente gli elementi 10, 20 e 30. C'è una casella immaginaria prima dell'elemento più a sinistra (l'elemento più a sinistra contiene il numero 10) che rappresenta la sentinella. È etichettato crend(). Il primo elemento nel vettore contiene il numero 10 ed è etichettato come 'ultimo elemento'. L'elemento più a destra nel vettore contiene 30 ed è etichettato crbegin().

Osservazioni:

ranges::crend() funziona su tutti gli intervalli bidirezionali, mentre std::crend() non può.

crend esempio

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::crend(v);
    --vi; // get off the sentinel and onto the last element in the reversed range
    std::cout << *vi; // outputs 10
    // vi[0] = 300; // error because the iterator is const    
    std::cout << *vi << ' ' << *--vi << ' ' << *--vi; // outputs 10, 20, 30
}

data

Ottenere un puntatore al primo elemento in un intervallo contiguo.

template<class T>
constexpr std::add_pointer_t<ranges::range_reference_t<T>> data(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Puntatore, in base al tipo dell'intervallo, al primo elemento dell'intervallo contiguo. Ad esempio, se l'intervallo è un vettore di numeri interi, il tipo del valore restituito è .int *

Esempio

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    std::string src{ "a string" };
   
    auto charPtr = std::ranges::data(src); // charPtr is a char *
    auto intPtr = std::ranges::data(v); // intPtr is an int *
    std::cout << charPtr << ", " << *intPtr << '\n'; // outputs a string, 10
    *intPtr = 100;
    *charPtr = 'A';
    std::cout << charPtr << ", " << *intPtr; // outputs A string, 100
}

empty

Verificare se l'intervallo è vuoto.

template<class T>
constexpr bool empty(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Restituisce true se l'intervallo non dispone di elementi; in caso contrario false, .

Esempio

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
        std::vector v{10,20,30};
    std::vector<int> v2;

    std::cout << std::boolalpha << std::ranges::empty(v); // outputs false
    std::cout << std::boolalpha << ", " << std::ranges::empty(v2); // outputs true
}

end

Ottenere la sentinella alla fine dell'intervallo.

template<class T>
std::sentinel_for<ranges::iterator_t<T>> auto end(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Sentinel che segue l'ultimo elemento nell'intervallo:

Immagine di un vettore con gli elementi 10, 20 e 30. Il primo elemento contiene 10 ed è etichettato begin(). L'ultimo elemento contiene 30 e viene etichettato come 'ultimo elemento'. Una casella immaginaria dopo l'ultimo elemento indica la sentinella ed è etichettata end().

Osservazioni:

ranges::end() funziona su tutti gli intervalli, mentre std::end() non può.

Esempio

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector<int> v = {10, 20, 30};
    auto i = std::ranges::end(v);
    --i; // get off the sentinel and onto the last element in the range
    std::cout << *i; // outputs 30
}

rbegin

Ottiene un iteratore inverso al primo elemento in un intervallo invertito. Un iteratore inverso restituisce gli elementi dell'intervallo in ordine inverso. L'intervallo stesso non è invertito; è possibile accedervi.

template<class T>
constexpr std::input_or_output_iterator auto rbegin(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Iteratore inverso al primo elemento dell'intervallo. Questo iteratore restituisce gli elementi dell'intervallo in ordine inverso, a partire dalla fine dell'intervallo invertito:

Immagine di un vettore contenente gli elementi 10, 20 e 30. C'è una casella immaginaria prima dell'elemento più a sinistra (l'elemento più a sinistra contiene il numero 10) che rappresenta la sentinella. Viene etichettato rend(). Il primo elemento nel vettore contiene il numero 10 ed è etichettato come 'ultimo elemento'. L'elemento più a destra nel vettore contiene 30 ed è etichettato rbegin().

Se l'intervallo è una matrice, restituisce l'equivalente di reverse_iterator{rg + n} dove n è il numero di elementi nella matrice. Se auto(rg.rbegin()) restituisce un iteratore, restituisce l'equivalente di auto(rg.rbegin()). Se tale espressione non è formata correttamente, auto(rbegin(rg)) viene utilizzata se tale espressione restituisce un iteratore.

Osservazioni:

ranges::rbegin() funziona su tutti gli intervalli bidirezionali, mentre std::rbegin() non può.

Esempio

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::rbegin(v);
    std::cout << *vi << ' ' << *++vi << ' ' << *++vi; // outputs 30 20 10
}

rend

Ottenere un iteratore inverso alla sentinella alla fine di una visualizzazione inversa dell'intervallo. Un iteratore inverso restituisce gli elementi dell'intervallo in ordine inverso. L'intervallo stesso non è invertito; è possibile accedervi.

template<class T>
constexpr 
std::sentinel_for<decltype(ranges::rbegin(std::declval<T>()))> auto rend(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Iteratore inverso verso la sentinella alla fine dell'intervallo. Sentinel segue l'ultimo elemento in una visualizzazione invertita dell'intervallo:

Immagine di un vettore contenente gli elementi 10, 20 e 30. C'è una casella immaginaria prima dell'elemento più a sinistra (l'elemento più a sinistra contiene il numero 10) che rappresenta la sentinella. Viene etichettato rend(). Il primo elemento nel vettore contiene il numero 10 ed è etichettato come 'ultimo elemento'. L'elemento più a destra nel vettore contiene 30 ed è etichettato rbegin().

Osservazioni:

ranges::rend() funziona su tutti gli intervalli bidirezionali, mentre std::rend() non può.

Esempio

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto vi = std::ranges::rend(v);
    --vi; // get off the sentinel and onto the last element in the reversed range
    std::cout << *vi; // outputs 10
    std::cout << *vi << ' ' << *--vi << ' ' << *--vi; // outputs 10, 20, 30
}

size

Ottiene il numero di elementi nell'intervallo come valore senza segno.

template<class T>
constexpr /*unsigned integer-like type */ size(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Numero di elementi nell'intervallo come valore intero senza segno.

Osservazioni:

Questa funzione viene eseguita in tempo costante.

Esempio

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto s = std::ranges::size(v); // s is a size_t
    std::cout << s; // outputs 3
}

ssize

Ottenere le dimensioni dell'intervallo come valore con segno.

template<class T>
constexpr /* signed-integer-like type */ ssize(T&& rg);

Parametri

T
Tipo dell'intervallo.

rg
Intervallo.

Valore restituito

Numero di elementi nell'intervallo come valore intero con segno.

Osservazioni:

Questa funzione viene eseguita in tempo costante.

Esempio

// requires /std:c++20 or later
#include <vector>
#include <ranges>
#include <iostream>

int main()
{
    std::vector v{10, 20, 30};
    auto s = std::ranges::ssize(v);
    std::cout << s; // outputs 3
}

Vedi anche

<ranges>
Che cosa sono gli oggetti di personalizzazione