Namespaces
Variants

std::ranges:: views:: common, std::ranges:: common_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::common_view
Definido en el encabezado <ranges>
template < ranges:: view V >

requires ( not ranges:: common_range < V > and
std:: copyable < ranges:: iterator_t < V >> )
class common_view

: public ranges:: view_interface < common_view < V >>
(1) (desde C++20)
namespace views {

inline constexpr /* no especificado */ common = /* no especificado */ ;

}
(2) (desde C++20)
Firma de llamada
template < ranges:: viewable_range R >

requires /* ver más abajo */

constexpr ranges:: view auto common ( R && r ) ;
(desde C++20)
1) Adapta una view dada con diferentes tipos para el par iterador/sentinel en una view que también es un common_range . Un common_view siempre tiene el mismo tipo de iterador/sentinel.
2) RangeAdaptorObject . Sea e una subexpresión. Entonces la expresión views :: common ( e ) es expression-equivalent a:
  • views:: all ( e ) , si es una expresión bien formada y decltype ( ( e ) ) modela common_range ;
  • common_view { e } en caso contrario.

Contenidos

Miembros de datos

Miembro Descripción
V base_ (privado) la vista subyacente
( objeto miembro solo para exposición* )

Funciones miembro

construye un common_view
(función miembro pública)
devuelve una copia de la vista subyacente (adaptada)
(función miembro pública)
devuelve un iterador al inicio
(función miembro pública)
devuelve un iterador al final
(función miembro pública)
devuelve el número de elementos, proporcionado solo si el rango subyacente (adaptado) satisface sized_range
(función miembro pública)
(C++26)
devuelve el tamaño aproximado del approximately_sized_range resultante
(función miembro pública)
Heredado de std::ranges::view_interface
devuelve si la vista derivada está vacía, proporcionado solo si satisface sized_range o forward_range
(función miembro pública de std::ranges::view_interface<D> )
(C++23)
devuelve un iterador constante al inicio del rango
(función miembro pública de std::ranges::view_interface<D> )
(C++23)
devuelve un centinela para el iterador constante del rango
(función miembro pública de std::ranges::view_interface<D> )
devuelve si la vista derivada no está vacía, proporcionado solo si ranges::empty es aplicable a ella
(función miembro pública de std::ranges::view_interface<D> )
obtiene la dirección de los datos de la vista derivada, proporcionado solo si su tipo de iterador satisface contiguous_iterator
(función miembro pública de std::ranges::view_interface<D> )
devuelve el primer elemento en la vista derivada, proporcionado si satisface forward_range
(función miembro pública de std::ranges::view_interface<D> )
devuelve el último elemento en la vista derivada, proporcionado solo si satisface bidirectional_range y common_range
(función miembro pública de std::ranges::view_interface<D> )
devuelve el n ésimo elemento en la vista derivada, proporcionado solo si satisface random_access_range
(función miembro pública de std::ranges::view_interface<D> )

Guías de deducción

Plantillas auxiliares

template < class T >

constexpr bool enable_borrowed_range < std :: ranges :: common_view < T >> =

ranges:: enable_borrowed_range < T > ;
(desde C++20)

Esta especialización de ranges::enable_borrowed_range hace que common_view satisfaga borrowed_range cuando la vista subyacente lo satisface.

Notas

common_view puede ser útil para trabajar con algoritmos heredados que esperan que el iterador y el centinela sean del mismo tipo.

Ejemplo

Ejecutar este código 
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <list>
#include <numeric>
#include <ranges>
int main()
{
    auto v1 = {1, 2, 3, 4, 5};
    auto i1 = std::counted_iterator{v1.begin(), std::ssize(v1)};
    auto r1 = std::ranges::subrange{i1, std::default_sentinel};
//  auto e1 = std::accumulate(r1.begin(), r1.end(), 0); // error: se requiere "rango común"
    auto c1 = std::ranges::common_view{r1};
    std::cout << "accumulate: " << std::accumulate(c1.begin(), c1.end(), 0) << '\n';
    // heredado de ranges::view_interface:
    std::cout << "c1.front(): " << c1.front() << '\n';
    std::cout << "c1.back(): " << c1.back() << '\n';
    std::cout << "c1.data(): " << c1.data() << '\n';
    std::cout << "c1[0]: " << c1[0] << '\n';
    auto v2 = std::list{1, 2, 3, 4, 5};
    auto i2 = std::counted_iterator{v2.begin(), std::ssize(v2)};
    auto r2 = std::ranges::subrange{i2, std::default_sentinel};
//  auto e2 = std::accumulate(r2.begin(), r2.end(), 0); // error: se requiere "rango común"
    auto c2 = std::ranges::common_view{ r2 };
    std::cout << "accumulate: " << std::accumulate(c2.begin(), c2.end(), 0) << '\n';
    // heredado de ranges::view_interface:
    std::cout << "c2.front(): " << c2.front() << '\n';
//  auto e3 = c2.back(); // error: se requiere "rango bidireccional"
//  auto e4 = c2.data(); // error: se requiere "rango contiguo"
//  auto e5 = c2[0];     // error: se requiere "rango de acceso aleatorio"
}

Salida posible: 

accumulate: 15
c1.front(): 1
c1.back(): 5
c1.data(): 0x7f19937f00d0
c1[0]: 1
accumulate: 15
c2.front(): 1

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3494 C++20 common_view nunca fue un borrowed_range es un borrowed_range si su vista subyacente lo es

Véase también

(C++20)
especifica que un rango tiene tipos de iterador y centinela idénticos
(concepto)
(C++20)
adapta un tipo de iterador y su centinela a un tipo de iterador común
(plantilla de clase)