subrange
classe (libreria standard C++)
Fornisce una visualizzazione di parte degli elementi di un intervallo come definito da un iteratore iniziale e sentinella.
Sintassi
template<input_or_output_iterator I, sentinel_for<I> S, subrange_kind K>
requires (K == subrange_kind::sized || !sized_sentinel_for<S, I>)
class subrange : public view_interface<subrange<I, S, K>>
Parametri del modello
I
Tipo di iteratore di inizio. Il input_or_output_iterator
concetto garantisce che I
sia un iteratore in grado di leggere tutti gli elementi.
K
Tipo di intervallo secondario: usare subrange_kind::sized
per specificare un intervallo secondario di dimensioni. Usare sized_sentinel_for<S, I>
se l'iteratore e sentinel possono essere sottratti per produrre le dimensioni. Il requisito subrange_kind::sized || !sized_sentinel_for<S, I>
archivia le dimensioni in locale nell'oggetto del sottorange e richiede di costruire il sottoinsieme usando il costruttore che accetta ( sized_range
per il quale si specifica subrange_kind::sized
qui) o tramite il costruttore che accetta un iterator
oggetto , sentinel
e size
(in modo da specificare sized_sentinel_for<S, I>
qui).
S
Tipo di iteratore finale. Il sized_sentinel_for
concetto garantisce che S
possa essere usato come sentinel per I
e che sia possibile calcolare la distanza tra sentinel e la posizione iteratore corrente in I
tempo costante.
Visualizzare le caratteristiche
Per una descrizione delle voci seguenti, vedere Visualizzare le caratteristiche della classe
Caratteristica | Descrizione |
---|---|
Adattatore di intervallo | views::counted |
Intervallo sottostante | Qualsiasi intervallo |
Tipo di elemento | iter_reference_t<I> |
Visualizzare la categoria iteratore | Uguale alla I categoria s |
Dimensioni | Se K è subrange::sized |
Iterabile const |
Se I è copiabile |
Intervallo comune | Se I e S sono dello stesso tipo. |
Intervallo preso in prestito | Sì |
Membri
Funzioni membro | Descrizione |
---|---|
Costruttori C++20 | Creare un oggetto subrange . |
operator PairLike C++20 |
Convertire un oggetto subrange in un tipo simile a una coppia. |
advance C++20 |
Spostare l'iteratore a una distanza specificata. |
begin |
Ottenere un iteratore al primo elemento. |
empty C++20 |
Verificare se l'oggetto subrange è vuoto. |
end C++20 |
Ottenere il sentinel alla fine dell'oggetto subrange . |
next C++20 |
Crea una copia di questo subrange oggetto, ma con l'iteratore archiviato spostato in avanti la distanza specificata. |
prev C++20 |
Crea una copia di questo subrange oggetto, ma con l'iteratore archiviato spostato indietro la distanza specificata. |
size C++20 |
Ottiene il numero di elementi. |
Ereditato da view_interface |
Descrizione |
back C++20 |
Ottiene l'ultimo elemento. |
data C++20 |
Ottenere un puntatore al primo elemento. |
front C++20 |
Ottenere il primo elemento. |
operator[] C++20 |
Ottiene l'elemento nella posizione specificata. |
operator bool C++20 |
Verificare se l'oggetto subrange è vuoto. |
Osservazioni:
Un subrange
oggetto è utile quando si dispone di un iteratore iniziale e finale, ma si vuole passare un singolo oggetto. Ad esempio, se si desidera chiamare un adattatore di intervallo ma aveva iteratori di inizio e fine, è possibile usare un subrange
oggetto per eseguirne il wrapping e passare l'oggetto subrange
all'adattatore di intervallo.
Requisiti
Intestazione: <ranges>
(da C++20)
Spazio dei nomi: std::ranges
Opzione del compilatore: /std:c++20
o versione successiva è obbligatoria.
Costruttori
Creare un oggetto subrange
.
1) subrange() requires default_initializable<I> = default;
2) template <Convertible_to_non_slicing<I> It>
constexpr subrange(It begin, S end) requires (!Store_size);
3) template <Convertible_to_non_slicing<I> It>
constexpr subrange(It begin, S end, const Size_type size) requires (K == subrange_kind::sized);
4) template <Not_same_as<subrange> rg>
requires borrowed_range<rg>
&& Convertible_to_non_slicing<iterator_t<rg>, I>
&& convertible_to<sentinel_t<rg>, S>
constexpr subrange(rg&& r) requires (!_Store_size || sized_range<rg>);
5) template <borrowed_range rg>
requires Convertible_to_non_slicing<iterator_t<rg>, I> && convertible_to<sentinel_t<rg>, S>
constexpr subrange(rg&& r, const _Size_type sizeHint) requires (K == subrange_kind::sized)
Parametri
begin
Iteratore che punta al primo elemento nell'intervallo secondario.
end
Sentinel che punta alla fine del sottoinsieme. L'elemento a cui punta non è incluso nell'intervallo secondario.
sizeHint
Dimensione dell'intervallo negli elementi. Viene usato per ottimizzare la size
funzione membro ed è necessario se si desidera creare una dimensione subrange
da un iteratore e sentinel i cui tipi non modellano sized_sentinel_for
.
Per informazioni sui tipi di parametri del modello, vedere Parametri del modello.
Valore restituito
Istanza di subrange
.
Osservazioni:
1) Il valore predefinito costruisce l'iteratore archiviato e sentinel. L'hint per le dimensioni è impostato su 0.
2) Usa std::move()
per spostare l'iteratore begin
e end
sentinel nell'iteratore archiviato e sentinel.
3) Inizializza l'iteratore archiviato con std::move(begin)
, l'oggetto sentinel archiviato con std::move(end)
e l'hint per le dimensioni archiviate con size
, che deve essere uguale alla distanza tra il primo e il secondo argomento.
4) Costruire un oggetto subrange
da un intervallo.
5) Il comportamento non è definito se szHint != ranges::distance(rg)
.
L'adattatore counted
di intervallo può creare un oggetto subrange
. Tale adattatore accetta un iteratore di inizio e un conteggio.
Esempio: counted
// requires /std:c++20 or later
#include <ranges>
#include <iostream>
#include <vector>
int main()
{
std::vector<int> v{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
auto pos5 = std::ranges::find(v, 5);
auto countedView = std::views::counted(pos5, 5);
for (auto e : countedView) // outputs 5 6 7 8 9
{
std::cout << e << ' ';
}
std::cout << '\n';
// You can pass the range directly if it supports input_or_output_iterator, in which case, the
// count starts from the first element
const char chars[] = { 'H','i',' ','t','h','e','r','e' };
for (char c : std::views::counted(chars, 2))
{
std::cout << c; // outputs Hi
}
}
5 6 7 8 9
Hi
operator PairLike
Convertire un oggetto subrange
in un tipo che modella pair-like
.
template<not-same-as<subrange> PairLike>
requires pair-like-convertible-from<PairLike, const I&, const S&>
constexpr operator PairLike() const;
Parametri
Nessuna.
Per informazioni sui tipi di parametri del modello, vedere Parametri del modello.
Valore restituito
Valore PairLike
inizializzato direttamente con l'iteratore archiviato e sentinel.
L'ultimo valore nella coppia sarà sentinel.
Tenere presente che sentinel è passato l'ultimo elemento nell'intervallo secondario, come illustrato nell'esempio seguente.
Osservazioni:
Questa conversione è utile con il codice precedente Boost::Ranges
che accetta coppie (prima, ultima) per indicare un intervallo.
Questa conversione è utile per convertire un intervallo secondario in un pair
tipo o tuple
in un altro tipo che modella pair_like
. Ecco alcuni esempi di pair_like
tipi:
std::array<T, 2>
std::pair<T, U>
std::ranges::subrange<I, S, K>
std::tuple<T, U>
Esempio: operator PairLike()
// requires /std:c++20 or later
#include <iostream>
#include <ranges>
#include <vector>
#include <utility>
int main()
{
constexpr int a[] = {0, 1, 2, 3, 4, 5};
std::ranges::subrange rg(a);
rg.advance(2);
const std::pair<const int*, const int*> p = rg;
for (auto e : rg)
{
std::cout << e << ' ';
}
// because the sentinel points after the last element, subtract one to get the last element
std::cout << '\n' << *p.first << ':' << *(p.second - 1) << '\n'; // outputs 2:5
}
2 3 4 5
2:5
advance
Regolare l'iteratore per questo subrange
oggetto in base agli n
elementi.
constexpr subrange& advance(const iter_difference_t<I> n);
Parametri
n
Numero di elementi per regolare l'iteratore. n
può essere positivo (spostarsi in avanti) o, se I
è bidirezionale, negativo (spostarsi all'indietro).
Osservazioni:
Questa funzione modifica lo stato corrente dell'iteratore nell'oggetto subrange
.
Se si passa oltre la fine di subrange
, l'iteratore viene impostato su sentinel alla fine di subrange
.
Se si avanza oltre l'inizio di subrange
(usando un valore negativo n
), si otterrà un'eccezione di parametro non valida se l'intervallo da creato subrange
non ha un elemento sul posto.
Esempioadvance
// requires /std:c++20 or later
#include <iostream>
#include <ranges>
#include <string>
#include <vector>
void print(const std::string &msg, auto &&v)
{
std::cout << msg << '\n';
for (auto& x : v)
{
std::cout << x << ' ';
}
std::cout << '\n';
}
int main()
{
std::vector v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
print("Original vector: ", v); // outputs 0 1 2 3 4 5 6 7 8 9 10
// create a subrange 3 4 5 6
std::ranges::subrange theSubrange{ std::ranges::find(v,3), std::ranges::find(v, 7) };
print("The subrange: ", theSubrange); // outputs 3 4 5 6
auto sr = theSubrange.advance(2); // get a subrange 2 positions to the right of the current iterator location
print("theSubrange.advance(2): ", sr); // outputs 5 6
print("Note that subrange's iterator moved during advance(): ", sr); // outputs 5 6
sr = theSubrange.advance(-3); // Moving before the subrange, but onto a valid element in the original range
print("theSubrange.advance(-3): ", sr); // outputs 2 3 4 5 6
}
Original vector:
0 1 2 3 4 5 6 7 8 9 10
The subrange:
3 4 5 6
theSubrange.advance(2):
5 6
Note that subrange's iterator moved during advance():
5 6
theSubrange.advance(-3):
2 3 4 5 6
begin
Ottenere un iteratore al primo elemento dell'oggetto subrange
.
1) constexpr I begin() const requires copyable<I>;
2) [[nodiscard]] constexpr I begin() requires (!std::copyable<I>);
Parametri
Nessuna.
Valore restituito
Iteratore che punta al primo elemento dell'oggetto subrange
.
Se l'iteratore non è copiabile, viene restituito con std::move()
. Se l'iteratore viene spostato, lo stato dell'iteratore archiviato dipende dall'implementazione del costruttore di spostamento per I
.
empty
Verificare se l'oggetto subrange
è vuoto.
constexpr bool empty() const;
Parametri
Nessuna.
Valore restituito
Restituisce true
se l'oggetto subrange
non dispone di elementi. In caso contrario, restituisce false
.
end
Ottenere la sentinella alla fine del subrange
[[nodiscard]] constexpr S end() const;
Parametri
Nessuna.
Valore restituito
Sentinel che segue l'ultimo elemento in subrange
:
Sentinel viene creato in copia dalla sentinel archiviata.
next
Crea una copia di questo subrange
oggetto, ma con l'iteratore archiviato spostato in avanti la distanza specificata.
1) [[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) const & requires forward_iterator<I>;
2) [[nodiscard]] constexpr subrange next(iter_difference_t<I> n = 1) &&;
Parametri
n
Numero di elementi per spostare l'iteratore in avanti. Assume il valore predefinito 1. Deve essere positivo.
Valore restituito
Restituisce una copia dell'oggetto subrange
a partire dall'elemento *n
*th.
Osservazioni:
A differenza di advance()
, next()
non modifica la posizione dell'iteratore archiviato nell'oggetto originale subrange
.
L'oggetto restituito subrange
contiene tutti gli elementi del sottorange originale, ma l'iteratore si trova in una posizione diversa.
1) Il valore restituito è uguale a:
auto tmp = *this;
tmp.advance(n);
return tmp;
2) Il valore restituito è uguale a:
advance(n);
return std::move(*this);
Esempio: next
// requires /std:c++20 or later
#include <iostream>
#include <ranges>
#include <string>
#include <vector>
void print(const std::string &msg, auto &&v)
{
std::cout << msg << '\n';
for (auto& x : v)
{
std::cout << x << ' ';
}
std::cout << '\n';
}
int main()
{
std::vector v = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
print("Original vector:", v); // 0 1 2 3 4 5 6 7 8 9 10
// create a subrange from the front of v up to (but not including) the element 7
std::ranges::subrange theSubrange{ std::ranges::find(v,1), std::ranges::find(v, 7) };
print("The subrange:", theSubrange); // 1 2 3 4 5 6
auto forward = theSubrange.advance(3); // get a subrange 3 positions to the right of the current iterator location
print("theSubrange.advance(3):", forward); // 4 5 6
// prev()
auto previous = theSubrange.prev(2); // move back 2
print("theSubrange.prev(2):", previous); // 2 3 4 5 6
print("Note that the subrange's iterator did *not* move during prev():", theSubrange); // 4 5 6
}
Original vector:
0 1 2 3 4 5 6 7 8 9 10
The subrange:
1 2 3 4 5 6
theSubrange.next(3):
4 5 6
Note that the original subrange's iterator did *not* move during next():
1 2 3 4 5 6
prev
Crea una copia di questo subrange
oggetto , ma con l'iteratore archiviato spostato indietro la distanza specificata.
[[nodiscard]] constexpr subrange prev(std::iter_difference_t<I> n = 1 ) const
requires std::bidirectional_iterator<I>;
Parametri
n
Numero di elementi per spostare nuovamente l'iteratore. Assume il valore predefinito 1. Deve essere positivo.
Valore restituito
Restituisce una copia dell'oggetto subrange
ma con gli elementi iteratori spostati indietro n
.
Osservazioni:
A differenza di advance()
, prev()
non modifica la posizione dell'iteratore archiviato nell'oggetto originale subrange
.
L'oggetto restituito subrange
contiene tutti gli elementi del sottorange originale, ma l'iteratore si trova solo in una posizione diversa. È possibile considerare il valore restituito come:
auto tmp = *this;
tmp.advance(-n);
return tmp;
Esempioprev
// requires /std:c++20 or later
#include <iostream>
#include <ranges>
#include <string>
#include <vector>
void print(const std::string &msg, auto &&v)
{
std::cout << msg << '\n';
for (auto& x : v)
{
std::cout << x << ' ';
}
std::cout << '\n';
}
int main()
{
std::vector v = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
print("Original vector:", v); // 0 1 2 3 4 5 6 7 8 9 10
// create a subrange from the front of v up to (but not including) the element 7
std::ranges::subrange theSubrange{std::ranges::find(v,1), std::ranges::find(v, 7)};
print("The subrange: ", theSubrange); // 1 2 3 4 5 6
auto forward = theSubrange.advance(3); // get a subrange 3 positions to the right of the current iterator location
print("theSubrange.advance(3):", forward); // 4 5 6
// prev()
auto previous = theSubrange.prev(2); // move back 2
print("theSubrange.prev(2):", previous); // 2 3 4 5 6
print("Note that the subrange's iterator did *not* move during prev():", theSubrange); // 4 5 6
}
Original vector:
0 1 2 3 4 5 6 7 8 9 10
The subrange:
1 2 3 4 5 6
theSubrange.advance(3):
4 5 6
theSubrange.prev(2):
2 3 4 5 6
Note that the subrange's iterator did *not* move during prev():
4 5 6
size
Ottiene il numero di elementi nell'oggetto subrange
.
constexpr size() const
requires (K == ranges::subrange_kind::sized);
Parametri
Nessuna.
Valore restituito
Numero di elementi in subrange
.
Se le dimensioni non vengono archiviate, ovvero quando l'oggetto subrange
viene creato con K == ranges::subrange_kind::sized
specificato e std::sized_sentinel_for<S, I>
non è soddisfatto, le dimensioni vengono restituite come distanza tra gli iteratori iniziale e finale.
La modifica della posizione dell'iteratore begin
, con advance
, ad esempio, modifica le dimensioni segnalate.