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

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 /* see below */ constexpr ranges::view auto cartesian_product( Rs&&... rs );		(desde C++23)
Conceptos auxiliares
template< bool Const, class First, class... Vs > concept /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 exposición*)
template< class R > concept /cartesian-product-common-arg/ = ranges::common_range<R> \|\| (ranges::sized_range<R> && ranges::random_access_range<R>);	(4)	(solo exposición*)
template< bool Const, class First, class... Vs > concept /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 exposición*)
template< class First, class... Vs > concept /cartesian-product-is-common/ = /cartesian-product-common-arg/<First>;	(6)	(solo exposición*)
template< class... Vs > concept /cartesian-product-is-sized/ = (ranges::sized_range<Vs> && ...);	(7)	(solo exposición*)
template< bool Const, template<class> class FirstSent, class First, class... Vs > concept /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 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 exposición*)

1) cartesian_product_view es un adaptador de rango que toma n vistas, donde n > 0, y produce una vista de tuplas calculada por 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) del tamaño n.

2) views::cartesian_product es un objeto de punto de personalización.

Al llamar sin argumentos, views::cartesian_product() es equivalente a expresión a views::single(std::tuple()).
De lo contrario, views::cartesian_product(rs...) es equivalente a expresión a ranges::cartesian_product_view<views::all_t<decltype((rs))>...>(rs...).

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 usa centinela dimensionado.

9) Devuelve el final de la vista producida. Participa en la resolución de sobrecarga solo si cartesian_product satisface el concepto auxiliar /*cartesian-product-common-arg*/.

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

First es un input_range en lugar de forward_range;
First no tiene que ser un sized_range para que el cartesian_product_view sea random_access_range o common_range;
First no tiene que ser common_range para que el cartesian_product_view sea bidirectional_range.

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	Descripción
`std::tuple<First, Vs...>` `base_` (privado)	un objeto que contiene todos los objetos `view` adaptados (objeto miembro de solo exposición*)

Funciones miembro

(constructor)	construye un `cartesian_product_view` (función miembro pública)
begin	devuelve un iterador al inicio (función miembro pública)
end	devuelve un iterador o centinela al final (función miembro pública)
size	devuelve el número de elementos, proporcionado solo si el rango subyacente (adaptado) satisface `sized_range` (función miembro pública)
Heredado de ranges::view_interface
empty	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>`)
cbegin (C++23)	devuelve un iterador constante al inicio del rango (función miembro pública de `std::ranges::view_interface<D>`)
cend (C++23)	devuelve un centinela para el iterador constante del rango (función miembro pública de `std::ranges::view_interface<D>`)
operator bool	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>`)
front	devuelve el primer elemento en la vista derivada, proporcionado si satisface `forward_range` (función miembro pública de `std::ranges::view_interface<D>`)
back	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>`)
operator[]	devuelve el `n`^º 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

iterator

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

ranges::zip_view views::zip

(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)

Soporte del compilador
Independiente y alojado
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos nombrados
Macros de prueba de características (C++20)
Biblioteca de soporte de lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnóstico
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de utilidades 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 de sistema de archivos (C++17)
Biblioteca de soporte de concurrencia (C++11)
Biblioteca de control de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas

Funciones miembro
cartesian_product_view::cartesian_product_view
cartesian_product_view::begin
cartesian_product_view::end
cartesian_product_view::size
Guías de deducción
Iterador
Funciones miembro
cartesian_product_view::iterator::iterator
cartesian_product_view::iterator::operator*
cartesian_product_view::iterator::operator[]
cartesian_product_view::iterator::operator++ cartesian_product_view::iterator::operator++(int) cartesian_product_view::iterator::operator-- cartesian_product_view::iterator::operator--(int) cartesian_product_view::iterator::operator+= cartesian_product_view::iterator::operator-=
cartesian_product_view::iterator::next
cartesian_product_view::iterator::prev
cartesian_product_view::iterator::distance_from
Funciones no miembro
operator==(cartesian_product_view::iterator) operator<=>(cartesian_product_view::iterator)
operator+(cartesian_product_view::iterator) operator-(cartesian_product_view::iterator)
iter_move(cartesian_product_view::iterator)
iter_swap(cartesian_product_view::iterator)

es.cppreference.net

Namespaces

Variants