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

Défini dans l'en-tête `<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)	(depuis C++23)
namespace views { inline constexpr /unspecified/ cartesian_product = /unspecified/; }	(2)	(depuis C++23)
Signature d'appel
template< ranges::viewable_range... Rs > requires /* see below */ constexpr ranges::view auto cartesian_product( Rs&&... rs );		(depuis C++23)
Concepts d'aide
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)	(exposé uniquement*)
template< class R > concept /cartesian-product-common-arg/ = ranges::common_range<R> \|\| (ranges::sized_range<R> && ranges::random_access_range<R>);	(4)	(exposé uniquement*)
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)	(exposé uniquement*)
template< class First, class... Vs > concept /cartesian-product-is-common/ = /cartesian-product-common-arg/<First>;	(6)	(exposé uniquement*)
template< class... Vs > concept /cartesian-product-is-sized/ = (ranges::sized_range<Vs> && ...);	(7)	(exposé uniquement*)
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)	(exposé uniquement*)
Patrons de fonctions d'aide
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)	(exposé uniquement*)

1) cartesian_product_view est un adaptateur de plage qui prend n vues, où n > 0, et produit une vue de tuples calculée par le produit cartésien n-aire des plages fournies. La taille de la vue produite est un multiple des tailles des plages fournies, tandis que chaque élément est un tuple (de références) de taille n.

2) views::cartesian_product est un objet point de personnalisation.

Lorsqu'il est appelé sans argument, views::cartesian_product() est équivalent à une expression à views::single(std::tuple()).
Sinon, views::cartesian_product(rs...) est équivalent à une expression à ranges::cartesian_product_view<views::all_t<decltype((rs))>...>(rs...).

3) Détermine si cartesian_product est une plage à accès aléatoire (voir aussi random_access_range).

4) Détermine si cartesian_product est une plage commune (voir aussi common_range).

5) Détermine si cartesian_product est une plage bidirectionnelle (voir aussi bidirectional_range).

6) Détermine si cartesian_product satisfait le concept d'aide /*cartesian-product-is-common*/ (voir aussi common_range).

7) Détermine si cartesian_product est une plage dimensionnée (voir aussi sized_range).

8) Détermine si cartesian_product utilise une sentinelle dimensionnée.

9) Renvoie la fin de la vue produite. Participe à la résolution de surcharge uniquement si cartesian_product satisfait le concept d'aide /*cartesian-product-common-arg*/.

La First plage passée à cartesian_product_view est traitée spécialement, car elle n'est transmise qu'une seule fois. En conséquence, plusieurs contraintes sont assouplies sur celle-ci :

First est une input_range au lieu d'une forward_range ;
First n'a pas besoin d'être une sized_range pour que la cartesian_product_view soit une random_access_range ou une common_range ;
First n'a pas besoin d'être une common_range pour que la cartesian_product_view soit une bidirectional_range.

Objets de point de personnalisation

Le nom views::cartesian_product désigne un objet de point de personnalisation , qui est un objet fonction constant d'un type de classe littéral semiregular . Voir CustomizationPointObject pour plus de détails.

Membres de données

Membre	Description
`std::tuple<First, Vs...>` `base_` (privé)	un objet qui contient tous les adaptés `view` objets (objet membre d'exposition uniquement*)

Fonctions membres

(constructeur)	construit un `cartesian_product_view` (fonction membre publique)
begin	retourne un itérateur vers le début (fonction membre publique)
end	retourne un itérateur ou un sentinelle vers la fin (fonction membre publique)
size	retourne le nombre d'éléments, fourni uniquement si la plage sous-jacente (adaptée) satisfait `sized_range` (fonction membre publique)
Hérité de ranges::view_interface
empty	renvoie si la vue dérivée est vide, fourni uniquement si elle satisfait `sized_range` ou `forward_range` (fonction membre publique de `std::ranges::view_interface<D>`)
cbegin (C++23)	renvoie un itérateur constant au début du domaine (fonction membre publique de `std::ranges::view_interface<D>`)
cend (C++23)	renvoie une sentinelle pour l'itérateur constant du domaine (fonction membre publique de `std::ranges::view_interface<D>`)
operator bool	renvoie si la vue dérivée n'est pas vide, fourni uniquement si ranges::empty lui est applicable (fonction membre publique de `std::ranges::view_interface<D>`)
front	renvoie le premier élément dans la vue dérivée, fourni si elle satisfait `forward_range` (fonction membre publique de `std::ranges::view_interface<D>`)
back	renvoie le dernier élément dans la vue dérivée, fourni uniquement si elle satisfait `bidirectional_range` et `common_range` (fonction membre publique de `std::ranges::view_interface<D>`)
operator[]	renvoie le `n`^ième élément dans la vue dérivée, fourni uniquement si elle satisfait `random_access_range` (fonction membre publique de `std::ranges::view_interface<D>`)

Guides de déduction

Classes imbriquées

iterator

le type d'itérateur
( classe de modèle membre d'exposition uniquement* )

Notes

Macro de test de fonctionnalité	Valeur	Std	Fonctionnalité
`__cpp_lib_ranges_cartesian_product`	`202207L`	(C++23)	`std::ranges::cartesian_product_view`

Exemple

Exécuter ce code

#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++);
}

Sortie :

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

Références

Norme C++23 (ISO/IEC 14882:2024) :

26.7.31 Vue de produit cartésien [range.stride]

Voir aussi

ranges::zip_view views::zip

(C++23)

une


           view

composée de tuples de références aux éléments correspondants des vues adaptées
(modèle de classe) (objet de point de personnalisation)

Support du compilateur
Autonome et hébergé
Langage
Bibliothèque standard
En-têtes de la bibliothèque standard
Exigences nommées
Macros de test de fonctionnalités (C++20)
Bibliothèque de support du langage
Bibliothèque de concepts (C++20)
Bibliothèque de diagnostics
Bibliothèque de gestion de la mémoire
Bibliothèque de métaprogrammation (C++11)
Bibliothèque d'utilitaires généraux
Bibliothèque de conteneurs
Bibliothèque d'itérateurs
Bibliothèque de plages (C++20)
Bibliothèque d'algorithmes
Bibliothèque de chaînes
Bibliothèque de traitement de texte
Bibliothèque numérique
Bibliothèque de date et heure
Bibliothèque d'entrée/sortie
Bibliothèque du système de fichiers (C++17)
Bibliothèque de support de la concurrence (C++11)
Bibliothèque de contrôle d'exécution (C++26)
Spécifications techniques
Index des symboles
Bibliothèques externes

Fonctions membres
cartesian_product_view::cartesian_product_view
cartesian_product_view::begin
cartesian_product_view::end
cartesian_product_view::size
Guides de déduction
Itérateur
Fonctions membres
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
Fonctions non membres
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)

fr.cppreference.net

Namespaces

Variants