std::ranges::take_view<V>::take_view

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de rangos

Acceso a rangos begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata empty

Conversiones de rangos std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Manejo de iteradores pendientes dangling borrowed_iterator_t borrowed_subrange_t

Primitivas de rangos
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Conceptos de rangos
range borrowed_range    sized_range	common_range view viewable_range	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	constant_range (C++23)

Vistas
view_interface	subrange

Fábricas de rangos
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Adaptadores de rangos
views::all_tviews::all ref_view owning_view as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while concat_viewviews::concat (C++26)(C++26) views::counted	drop_viewviews::drop drop_while_viewviews::drop_while join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   lazy_split_viewviews::lazy_split split_viewviews::split common_viewviews::common cache_latest_viewviews::cache_latest (C++26)(C++26)	reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Generadores de rangos std::generator (C++23)

Objetos cierre adaptadores de rangos range_adaptor_closure (C++23)

Objetos adaptadores de rangos

Elementos auxiliares
copyable-box movable-box (hasta C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::take_view

Funciones miembro

take_view::take_view (C++20)

take_view::base (C++20)

take_view::begin (C++20)

take_view::end (C++20)

take_view::size (C++20)

Guías de deducción

Centinela

take_view::sentinel::sentinel (C++20)

take_view::sentinel::base (C++20)

operator==(std::counted_iterator,take_view::sentinel) (C++20)

 

take_view() requires std::default_initializable<V> = default;	(1)	(desde C++20)
constexpr take_view( V base, ranges::range_difference_t<V> count );	(2)	(desde C++20)

Construye un objeto take_view.

1) Constructor por defecto. Inicializa por valor la vista subyacente e inicializa la cuenta en 0. Después de la construcción, base() devuelve una copia de V() y size() devuelve 0.

2) Inicializa la vista subyacente con std::move(base) y la cuenta con count. Después de la construcción, base() devuelve una copia de base y size() devuelve el menor de count y ranges::size(base).

Parámetros

base	-	La vista subyacente.
count	-	El número de elementos a tomar.

Ejemplo

Imprime los primeros n números primos que se generan usando el método de la Criba de Eratóstenes.

Ejecuta este código

#include <bit>
#include <bitset>
#include <iomanip>
#include <iostream>
#include <limits>
#include <ranges>

constexpr unsigned clog2(auto x) // ~ ⌈ log₂(x) ⌉
{
    return std::numeric_limits<decltype(x)>::digits - std::countl_zero(x);
}

template <unsigned Primos> struct Criba
{
    bool operator()(int n) {
        if (n < 2) return false;
        if (n == 2) return true;
        if (n % 2 == 0 || bits.test(n / 2))
            return false;
        for (int i{n}, j{3}, k{}; (k = i * j) < tam; j += 2)
            bits.set(k / 2);
        return true;
    }

    static constexpr int num_primos = Primos;

    // a(n) ~= n*(log(n) + log(log(n))); tam es el tamaño
    static constexpr int tam = Primos*(clog2(Primos) + clog2(clog2(Primos)));

    // Conservar solo los números nones; 0 significa que es un primo
    private: std::bitset<tam / 2 + 1> bits;
};

int main()
{
    Criba<100> criba{};
    auto gen_de_primos = std::views::iota(1)
                    | std::views::filter(criba);

    auto primos = std::ranges::take_view{ gen_de_primos, criba.num_primos };

    for (int n{1}; auto primo : primos) {
        std::cout << primo << (n++ % 10 ? ' ' : '\n');
    }

    std::cout
        << "\n" "criba.num_primos: " << criba.num_primos
        << "\n" "criba.tam: " << criba.tam
        << "\n" "sizeof(criba): " << sizeof criba << " bytes\n";
}

Salida:

2 3 5 7 11 13 17 19 23 29
31 37 41 43 47 53 59 61 67 71
73 79 83 89 97 101 103 107 109 113
127 131 137 139 149 151 157 163 167 173
179 181 191 193 197 199 211 223 227 229
233 239 241 251 257 263 269 271 277 281
283 293 307 311 313 317 331 337 347 349
353 359 367 373 379 383 389 397 401 409
419 421 431 433 439 443 449 457 461 463
467 479 487 491 499 503 509 521 523 541

criba.num_primos: 100
criba.tam: 1000
sizeof(criba): 64 bytes