Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Bereichsadaptoren
     
    std::ranges::cartesian_product_view
    Mitgliedsfunktionen
    Ableitungsleitfäden
    Iterator
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
     
    Definiert in 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 /* see below */
constexpr ranges::view auto cartesian_product( Rs&&... rs );
    		(seit C++23)
    Hilfskonzepte
    		 
    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) (nur zur Veranschaulichung*) 
    template< class R >
concept /*cartesian-product-common-arg*/ =
    ranges::common_range<R> ||
        (ranges::sized_range<R> && ranges::random_access_range<R>);
    		(4) (nur zur Veranschaulichung*) 
    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) (nur zur Veranschaulichung*) 
    template< class First, class... Vs >
concept /*cartesian-product-is-common*/ =
    /*cartesian-product-common-arg*/<First>;
    		(6) (nur zur Veranschaulichung*) 
    template< class... Vs >
concept /*cartesian-product-is-sized*/ =
    (ranges::sized_range<Vs> && ...);
    		(7) (nur zur Veranschaulichung*) 
    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) (nur zur Veranschaulichung*)
    Hilfsfunktionsschablonen
    		 
    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) (nur zur Veranschaulichung*)
    1) cartesian_product_view ist ein Bereichsadaptor, der n Ansichten nimmt, wobei n > 0, und eine Ansicht von Tupeln erzeugt, die durch das n-stellige kartesische Produkt der bereitgestellten Bereiche berechnet werden. Die Größe der erzeugten Ansicht ist ein Vielfaches der Größen der bereitgestellten Bereiche, während jedes Element ein Tupel (von Referenzen) der Größe n ist.
    2) views::cartesian_product ist ein Anpassungspunktobjekt.
    • Beim Aufruf ohne Argument ist views::cartesian_product() ausdrucksäquivalent zu views::single(std::tuple()).
    • Andernfalls ist views::cartesian_product(rs...) ausdrucksäquivalent zu ranges::cartesian_product_view<views::all_t<decltype((rs))>...>(rs...).
    3) Bestimmt, ob cartesian_product ein Random-Access-Bereich ist (siehe auch random_access_range).
    4) Bestimmt, ob cartesian_product ein gemeinsamer Bereich ist (siehe auch common_range).
    5) Bestimmt, 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 bemessener Bereich ist (siehe auch sized_range).
    8) Bestimmt, ob cartesian_product einen bemessenen Sentinel verwendet.
    9) Gibt das Ende der erzeugten Ansicht zurück. Nimmt nur an der Überladungsauflösung teil, wenn cartesian_product das Hilfskonzept /*cartesian-product-common-arg*/ erfüllt.

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

    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 .

    Datenelemente

    Element Beschreibung
    std::tuple<First, Vs...> base_ (privat) ein Objekt, das alle adaptierten View-Objekte enthält
    (nur zur Darstellung dienendes Elementobjekt*)

    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 ranges::view_interface
    		gibt zurück, ob die abgeleitete Ansicht leer ist, nur dann verfügbar, wenn sie sized_range oder forward_range
    (ö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, nur dann verfügbar, wenn ranges::empty auf sie anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten Ansicht zurück, nur dann verfügbar, wenn sie forward_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten Ansicht zurück, nur dann verfügbar, wenn sie bidirectional_range und common_range
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das nte Element in der abgeleiteten Ansicht zurück, nur dann verfügbar, wenn sie random_access_range
    (ö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)