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
Definiert im Header <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) (seit C++23)
namespace views {

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

}
(2) (seit C++23)
Aufrufsignatur
template < ranges:: viewable_range ... Rs >

requires /* siehe unten */

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

Konzept /*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) ( Nur zur Darstellung* )
template < class R >

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

( ranges:: sized_range < R > && ranges:: random_access_range < R > ) ;
(4) ( nur zur Darstellung* )
template < bool Const, class First, class ... Vs >

Konzept /*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) ( Nur zur Darstellung* )
template < class First, class ... Vs >

concept /*kartesisches-produkt-ist-gemeinsam*/ =

/*kartesisches-produkt-gemeinsames-argument*/ < First > ;
(6) ( nur zur Darstellung* )
template < class ... Vs >

concept /*Kartesisches-Produkt-hat-Größe*/ =

( ranges:: sized_range < Vs > && ... ) ;
(7) ( Nur zur Darstellung* )
template < bool Const, template < class > class FirstSent, class First, class ... Vs >

Konzept /*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) ( Nur zur Darstellung* )
Hilfsfunktions-Templates
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) ( exposition only* )
1) cartesian_product_view ist ein Range-Adaptor, der n view s akzeptiert, wobei n > 0 , und eine view von Tupeln erzeugt, die durch das n-äre kartesische Produkt der bereitgestellten Ranges berechnet werden. Die Größe der erzeugten View ist ein Vielfaches der Größen der bereitgestellten Ranges, während jedes Element ein Tupel (von Referenzen) der Größe n ist.
2) views::cartesian_product ist ein Customization Point Object.
3) Bestimmt, ob cartesian_product ein Random-Access-Range ist (siehe auch random_access_range ).
4) Bestimmt, ob cartesian_product ein common range ist (siehe auch common_range ).
5) Stellt fest, ob cartesian_product ein bidirektionaler Bereich ist (siehe auch bidirectional_range ).
6) Bestimmt, ob cartesian_product das Hilfskonzept /*cartesian-product-is-common*/ erfüllt (siehe auch common_range ).
7) Bestimmt, ob cartesian_product ein sized range ist (siehe auch sized_range ).
8) Bestimmt, ob cartesian_product einen sized sentinel verwendet.
9) Gibt das Ende der erzeugten view zurück. Nimmt nur dann an der Überladungsauflösung teil, wenn cartesian_product das Hilfskonzept /*cartesian-product-common-arg*/ erfüllt.

Der First range , der an cartesian_product_view übergeben wird, wird speziell behandelt, da er nur einmal durchlaufen wird. Daher werden mehrere Einschränkungen für ihn gelockert:

Inhaltsverzeichnis

Customization Point Objects

Der Name views::cartesian_product bezeichnet ein Customization Point Object , welches ein konstantes Function Object eines Literal semiregular Klassentyps ist. Weitere Details finden Sie unter CustomizationPointObject .

Datenmitglieder

Member Definition
std:: tuple < First, Vs... > base_ (private) Ein Objekt, das alle adaptierten view Objekte enthält.
( Nur zur Darstellung verwendetes Member-Objekt* )

Memberfunktionen

konstruiert einen cartesian_product_view
(öffentliche Elementfunktion)
gibt einen Iterator zum Anfang zurück
(öffentliche Elementfunktion)
gibt einen Iterator oder Sentinel zum Ende zurück
(öffentliche Elementfunktion)
gibt die Anzahl der Elemente zurück, bereitgestellt nur wenn der zugrundeliegende (adaptierte) Bereich sized_range erfüllt
(öffentliche Elementfunktion)
Geerbt von std::ranges::view_interface
gibt zurück ob die abgeleitete Ansicht leer ist, bereitgestellt nur wenn sie sized_range oder forward_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
(C++23)
gibt einen konstanten Iterator zum Anfang des Bereichs zurück
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
(C++23)
gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt zurück ob die abgeleitete Ansicht nicht leer ist, bereitgestellt nur wenn ranges::empty darauf anwendbar ist
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das erste Element in der abgeleiteten Ansicht zurück, bereitgestellt wenn sie forward_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das letzte Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie bidirectional_range und common_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )
gibt das n te Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie random_access_range erfüllt
(öffentliche Elementfunktion von std::ranges::view_interface<D> )

Ableitungsleitfäden

Geschachtelte Klassen

Der Iteratortyp
( Nur zur Darstellung dienende Member-Klassenvorlage* )

Hinweise

Feature-Test Makro Wert Std Feature
__cpp_lib_ranges_cartesian_product 202207L (C++23) std::ranges::cartesian_product_view

Beispiel

Diesen Code ausführen 
#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++);
}

Ausgabe: 

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

Referenzen

  • C++23-Standard (ISO/IEC 14882:2024):
  • 26.7.31 Cartesian-Produkt-Ansicht [range.stride]

Siehe auch

(C++23)
eine view bestehend aus Tupeln von Referenzen auf entsprechende Elemente der adaptierten Views
(Klassentemplate) (Customization Point Object)