Classe iota_view (Biblioteca Padrão C++)

Gera uma exibição de uma sequência de elementos incrementando repetidamente um valor inicial. A sequência pode ser limitada ou não limitada.

Sintaxe

template<std::weakly_incrementable W, std::semiregular Bound = std::unreachable_sentinel_t>
    requires __WeaklyEqualityComparableWith<W, Bound> && std::copyable<W>
class iota_view : public ranges::view_interface<iota_view<W, Bound>>;

Parâmetros de modelo

W
O tipo dos valores na sequência. O tipo especificado deve dar suporte a operator++.

Bound
O tipo do valor final. Se Bound for std::unreachable_sentinel_t (o valor padrão), a exibição será ilimitada.

Ver características

Para obter uma descrição das entradas a seguir, consulte Exibir características da classe

Característica	Descrição
Adaptador de gama	views::iota
Intervalo subjacente	Não aplicável porque essa exibição gera seus membros
Tipo de elemento	O mesmo que o parâmetro de modelo W
Exibir categoria do iterador	Suporta input_range até random_access_range, dependendo do tipo de W
Tamanho	Somente se o intervalo tiver um valor final, ou seja, não for uma série infinita
É const-iterável	Sim
Faixa comum	Somente se Bound for do mesmo tipo que W
Alcance emprestado	Sim

Membros

Funções de membro	Descrição
Construtores C++20	Construa a exibição.
beginC++20	Obtenha um iterador para o primeiro elemento.
endC++20	Pegue a sentinela no final da vista.
sizeC++20	Obtenha o número de elementos.
Herdado de view_interface	Descrição
backC++20	Obtenha o último elemento.
emptyC++20	Teste se a exibição está vazia.
frontC++20	Obtenha o primeiro elemento.
operator[]C++20	Obter o elemento na posição especificada.
operator boolC++20	Teste se a exibição não está vazia.

Comentários

Uma boa maneira de criar um iota_view é usando o adaptador de iota intervalo. Os adaptadores de intervalo são a maneira pretendida de criar classes de exibição. Os tipos de exibição são expostos caso você queira criar seu próprio tipo de exibição personalizado.

A sequência de valores pode ser valores integrais, como 1,2,3 ou 'a', 'b', 'c' ou elementos consecutivos de um intervalo.

Essa exibição normalmente é usada para iterar em uma série de valores. Por exemplo:

for (int i : iota_view{1, 10}) // iterate over a view of the integers 1 through 9
{
    std::cout << i << ’ ’; // 1 2 3 4 5 6 7 8 9
}

Requisitos

Cabeçalho: <ranges> (desde C++20)

Namespace: std::ranges

Opção do compilador: /std:c++20 ou posterior é necessária.

Construtores

Crie uma instância de um iota_viewarquivo .

1) iota_view() requires std::default_initializable<W> = default;
2) constexpr explicit iota_view(W value);
3) constexpr iota_view(std::type_identity_t<W> value, std::type_identity_t<Bound> bound);
4) constexpr iota_view( /*iterator*/ first, /*sentinel*/ last );

Parâmetros

value
O valor inicial da série.

bound
O limite da série. É um valor maior que o último da série.

Para obter informações sobre o tipo de parâmetro de modelo, consulte Parâmetros de modelo.

Comentários

1) Crie um iota_view com um valor inicial e final determinado pelo tipo Wde modelo inicializado por padrão.
2) Crie um iota_view com o valor inicial especificado e o valor final determinado pelo tipo Winicializado por valor.
3) Crie um limitado iota_view com o valor inicial e o valor final especificados. O valor final é um a menos que o último valor especificado.
4) Usado para criar subviews. Por exemplo, std::ranges::iota_view(start, end); onde start e end são iteradores para o início e o fim da subvisualização.

Em vez de criar essa classe diretamente, uma maneira fácil de criar uma iota_view é usando o adaptador de iota intervalo. Os adaptadores de intervalo são a maneira pretendida de criar classes de exibição. Os tipos de exibição são expostos caso você queira criar seu próprio tipo de exibição personalizado.

Se o tipo do limite for unreachable_sentinel_t, a exibição resultante será limitada.

Quando você usa um dos construtores que inicializa o valor do associado, o limite será o valor inicializado por padrão para esse tipo. Por exemplo, iota_view<int, int>{} é um intervalo vazio de int uma vez que o valor int construído por padrão e o limite são ambos 0. Além disso, iota_view<int, int>{-4} é -4, -3, -2, -1 porque o limite construído int por padrão é 0.

iota_view Exemplo de construtor

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

int main()
{
    std::ranges::iota_view<int> iv; // create an iota_view with an unbounded range, starting at 0 
    std::ranges::iota_view<int> iv2(5); // create an iota_view with an unbounded range, starting at 5.
    std::ranges::iota_view<int, int> iv3{5, 10}; // create an iota_view with a bounded range, starting at 5 and ending at 9
    
    std::vector<int> v{10, 20, 35, 45, 50, 66, 77, 82, 90, 100};
    auto start = std::ranges::find(v, 35);
    auto end = std::ranges::find(v, 82);
    for (auto &&val : std::ranges::iota_view(start, end))
    {
        std::cout << *val << ' '; // outputs 35 45 50 66 77
    }
}

begin

Obtenha um iterador para o primeiro elemento na exibição.

constexpr auto begin();
constexpr auto begin() const requires range<const V>;

Parâmetros

Nenhum.

Valor retornado

Um iterador apontando para o primeiro elemento na exibição.

end

Obtenha a sentinela final no final da exibição.

constexpr auto end();
constexpr auto end() const requires ranges::range<const V>;

Parâmetros

Nenhum.

Valor retornado

Se o iota_view for ilimitado, retornará std::unreachable_sentinel.

Se o iota_view for limitado, retornará um iterador apontando para o sentinela após o último valor na sequência.

size

Obtenha o número de elementos na exibição. O iota_view deve ser limitado.

constexpr auto size() requires
    (same_as<W, Bound> && advanceable <W>) ||
    (integral<W> && integral<Bound>) ||
    sized_sentinel_for<Bound, W>;

Parâmetros

Nenhum.

Valor retornado

O número de elementos em iota_view.

Comentários

Você não pode chamar size() um iota_view.

Confira também

<ranges>
iota() adaptador de gama
std::numerics::iota
Ver aulas