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
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 /* voir ci-dessous */

constexpr ranges:: view auto cartesian_product ( Rs && ... rs ) ;
(depuis C++23)
Concepts auxiliaires
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) ( exposition uniquement* )
template < class R >

concept /*produit-cartésien-argument-commun*/ =
ranges:: common_range < R > ||

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

concept /*produit-cartésien-est-bidirectionnel*/ =
( ranges:: bidirectional_range < /*peut-être-const*/ < Const, First >> && ... &&
( ranges:: bidirectional_range < /*peut-être-const*/ < Const, Vs >> &&

/*argument-commun-produit-cartésien*/ < /*peut-être-const*/ < Const, Vs >> ) ) ;
(5) ( exposition uniquement* )
template < class First, class ... Vs >

concept /*produit-cartésien-est-commun*/ =

/*argument-commun-produit-cartésien*/ < First > ;
(6) ( exposition uniquement* )
template < class ... Vs >

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

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

concept /*sentinel-de-taille-cartesien*/ =
( std:: sized_sentinel_for < FirstSent < /*peut-être-const*/ < Const, First >> ,
ranges:: iterator_t < /*peut-être-const*/ < Const, First >>> && ... &&
( ranges:: sized_range < /*peut-être-const*/ < Const, Vs >> &&
std:: sized_sentinel_for < ranges:: iterator_t <
/*peut-être-const*/ < Const, Vs >> ,

ranges:: iterator_t < /*peut-être-const*/ < Const, Vs >>> ) ) ;
(8) ( exposition uniquement* )
Modèles de fonctions d'assistance
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 uniquement* )
1) cartesian_product_view est un adaptateur de gamme qui prend n view s , où n > 0 , et produit une view de tuples calculés par le produit cartésien n-aire des gammes fournies. La taille de la vue produite est un multiple des tailles des gammes fournies, tandis que chaque élément est un tuple (de références) de taille n .
2) views::cartesian_product est un objet de point de personnalisation.
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 auxiliaire /*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 un sentinel dimensionné.
9) Retourne la fin de la view produite. Participe à la résolution de surcharge uniquement si cartesian_product satisfait le concept d'aide /*cartesian-product-common-arg*/ .

Le First range passé à cartesian_product_view est traité spécialement, car il n'est parcouru qu'une seule fois. En conséquence, plusieurs contraintes sont assouplies pour celui-ci :

Table des matières

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 Définition
std:: tuple < First, Vs... > base_ (privé) Un objet qui contient tous les objets view adaptés.
( objet membre d'exposition uniquement* )

Fonctions membres

construit un cartesian_product_view
(fonction membre publique)
retourne un itérateur vers le début
(fonction membre publique)
retourne un itérateur ou un sentinelle vers la fin
(fonction membre publique)
retourne le nombre d'éléments, fourni uniquement si la plage sous-jacente (adaptée) satisfait sized_range
(fonction membre publique)
Hérité de std::ranges::view_interface
indique 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> )
(C++23)
retourne un itérateur constant vers le début de la plage
(fonction membre publique de std::ranges::view_interface<D> )
(C++23)
retourne un sentinelle pour l'itérateur constant de la plage
(fonction membre publique de std::ranges::view_interface<D> )
indique 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> )
retourne le premier élément de la vue dérivée, fourni si elle satisfait forward_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le dernier élément de la vue dérivée, fourni uniquement si elle satisfait bidirectional_range et common_range
(fonction membre publique de std::ranges::view_interface<D> )
retourne le n ième élément de 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

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

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