Namespaces
Variants

std::ranges:: views:: cartesian_product, std::ranges:: cartesian_product_view

From cppreference.net
C++
Ranges library
Range adaptors
(C++23) (C++23)
(C++23)
(C++23) (C++23)
(C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)
(C++23) (C++23)
cartesian_product_view views::cartesian_product
(C++23) (C++23)

std::ranges::cartesian_product_view
Member functions
Deduction guides
Iterator
Member functions
Non-member functions
Definido en el encabezado <ranges>
template < ranges:: input_range First, ranges:: forward_range ... Vs >

requires ( ranges:: view < First > && ... && ranges:: view < Vs > )
class cartesian_product_view

: public ranges:: view_interface < cartesian_product_view < First, Vs... >>
(1) (desde C++23)
namespace views {

inline constexpr /*unspecified*/ cartesian_product = /*unspecified*/ ;

}
(2) (desde C++23)
Firma de llamada
template < ranges:: viewable_range ... Rs >

requires /* ver abajo */

constexpr ranges:: view auto cartesian_product ( Rs && ... rs ) ;
(desde C++23)
Conceptos auxiliares
template < bool Const, class First, class ... Vs >

concepto /*cartesian-product-is-random-access*/ =
( ranges:: random_access_range < /*maybe-const*/ < Const, First >> && ... &&
( ranges:: random_access_range < /*maybe-const*/ < Const, Vs >> &&

ranges:: sized_range < /*maybe-const*/ < Const, Vs >> ) ) ;
(3) ( solo para exposición* )
template < class R >

concepto /*cartesian-product-common-arg*/ =
ranges:: common_range < R > ||

( ranges:: sized_range < R > && ranges:: random_access_range < R > ) ;
(4) ( solo para exposición* )
template < bool Const, class First, class ... Vs >

concepto /*cartesian-product-is-bidirectional*/ =
( ranges:: bidirectional_range < /*maybe-const*/ < Const, First >> && ... &&
( ranges:: bidirectional_range < /*maybe-const*/ < Const, Vs >> &&

/*cartesian-product-common-arg*/ < /*maybe-const*/ < Const, Vs >> ) ) ;
(5) ( solo para exposición* )
template < class First, class ... Vs >

concepto /*cartesian-product-is-common*/ =

/*cartesian-product-common-arg*/ < First > ;
(6) ( solo para exposición* )
template < class ... Vs >

concepto /*cartesian-product-is-sized*/ =

( ranges:: sized_range < Vs > && ... ) ;
(7) ( solo para exposición* )
template < bool Const, template < class > class FirstSent, class First, class ... Vs >

concepto /*cartesian-is-sized-sentinel*/ =
( std:: sized_sentinel_for < FirstSent < /*maybe-const*/ < Const, First >> ,
ranges:: iterator_t < /*maybe-const*/ < Const, First >>> && ... &&
( ranges:: sized_range < /*maybe-const*/ < Const, Vs >> &&
std:: sized_sentinel_for < ranges:: iterator_t <
/*maybe-const*/ < Const, Vs >> ,

ranges:: iterator_t < /*maybe-const*/ < Const, Vs >>> ) ) ;
(8) ( solo para exposición* )
Plantillas de funciones auxiliares
template < /*cartesian-product-common-arg*/ R >

constexpr auto /*cartesian-common-arg-end*/ ( R & r )
{
if constexpr ( ranges:: common_range < R > )
return ranges:: end ( r ) ;
else
return ranges:: begin ( r ) + ranges:: distance ( r ) ;

}
(9) ( solo para exposición* )
1) cartesian_product_view es un adaptador de rango que toma n view s , donde n > 0 , y produce una view de tuplas calculadas mediante el producto cartesiano n-ario de los rangos proporcionados. El tamaño de la vista producida es un múltiplo de los tamaños de los rangos proporcionados, mientras que cada elemento es una tupla (de referencias) de tamaño n .
2) views::cartesian_product es un objeto de punto de personalización.
3) Determina si cartesian_product es un rango de acceso aleatorio (ver también random_access_range ).
4) Determina si cartesian_product es un rango común (ver también common_range ).
5) Determina si cartesian_product es un rango bidireccional (ver también bidirectional_range ).
6) Determina si cartesian_product satisface el concepto auxiliar /*cartesian-product-is-common*/ (ver también common_range ).
7) Determina si cartesian_product es un rango dimensionado (ver también sized_range ).
8) Determina si cartesian_product utiliza un centinela de tamaño definido.
9) Retorna el final de la view producida. Participa en la resolución de sobrecarga solo si cartesian_product satisface el concepto auxiliar /*cartesian-product-common-arg*/ .

El First range pasado a cartesian_product_view se trata de manera especial, ya que solo se pasa una única vez. Como resultado, varias restricciones se relajan en él:

Contenidos

Objetos de punto de personalización

El nombre views::cartesian_product denota un objeto de punto de personalización , que es un objeto función constante de tipo clase literal semiregular . Consulte CustomizationPointObject para más detalles.

Miembros de datos

Miembro Definición
std:: tuple < First, Vs... > base_ (privado) Un objeto que contiene todos los objetos view adaptados.
( objeto miembro solo para exposición* )

Funciones miembro

construye un cartesian_product_view
(función miembro pública)
devuelve un iterador al inicio
(función miembro pública)
devuelve un iterador o centinela 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)
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> )
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 th 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

Clases anidadas

el tipo de iterador
( clase plantilla miembro solo para exposición* )

Notas

Macro de prueba de características Valor Estándar Característica
__cpp_lib_ranges_cartesian_product 202207L (C++23) std::ranges::cartesian_product_view

Ejemplo

Ejecutar este código 
#include <array>
#include <iostream>
#include <list>
#include <ranges>
#include <string>
#include <vector>
void print(std::tuple<char const&, int const&, std::string const&> t, int pos)
{
    const auto& [a, b, c] = t;
    std::cout << '(' << a << ' ' << b << ' ' << c << ')' << (pos % 4 ? " " : "\n");
}
int main()
{
    const auto x = std::array{'A', 'B'};
    const auto y = std::vector{1, 2, 3};
    const auto z = std::list<std::string>{"α", "β", "γ", "δ"};
    for (int i{1}; auto const& tuple : std::views::cartesian_product(x, y, z))
        print(tuple, i++);
}

Salida: 

(A 1 α) (A 1 β) (A 1 γ) (A 1 δ)
(A 2 α) (A 2 β) (A 2 γ) (A 2 δ)
(A 3 α) (A 3 β) (A 3 γ) (A 3 δ)
(B 1 α) (B 1 β) (B 1 γ) (B 1 δ)
(B 2 α) (B 2 β) (B 2 γ) (B 2 δ)
(B 3 α) (B 3 β) (B 3 γ) (B 3 δ)

Referencias

  • Estándar C++23 (ISO/IEC 14882:2024):
  • 26.7.31 Vista de producto cartesiano [range.stride]

Véase también

(C++23)
una view que consiste en tuplas de referencias a elementos correspondientes de las vistas adaptadas
(plantilla de clase) (objeto de punto de personalización)