Namespaces
Variants

    std::ranges::views::zip, std::ranges::zip_view

    Aus de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Range-Adaptoren
     
    std::ranges::zip_view
    Mitgliedsfunktionen
    Ableitungsregeln
    Iterator
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Sentinel
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
     
    Definiert in Header <ranges> 
    template< ranges::input_range... Views >
    requires (ranges::view<Views> && ...) && (sizeof...(Views) > 0)
class zip_view
    : public ranges::view_interface<zip_view<Views...>>
    		(1) (seit C++23) 
    namespace views {
    inline constexpr /*unspecified*/ zip = /*unspecified*/;
}
    		(2) (seit C++23)
    Aufrufsignatur
    		 
    template< ranges::viewable_range... Rs >
    requires /* see below */
constexpr ranges::view auto zip( Rs&&... rs );
    		(seit C++23)
    1) zip_view ist ein Range-Adaptor, der einen oder mehrere views nimmt und einen view erzeugt, dessen ites Element ein tupelartiger Wert ist, der aus dem iten Element aller Views besteht. Die Größe des erzeugten Views ist das Minimum der Größen aller angepassten Views.
    2) views::zip ist ein Anpassungspunktobjekt.

    Beim Aufruf ohne Argument ist views::zip() ausdrucksäquivalent zu auto(views::empty<std::tuple<>>).
    Andernfalls ist views::zip(rs...) ausdrucksäquivalent zu ranges::zip_view<views::all_t<decltype((rs))>...>(rs...).

    zip_view modelliert immer input_range und modelliert forward_range, bidirectional_range, random_access_range oder sized_range, wenn alle angepassten view-Typen das entsprechende Konzept modellieren.

    zip_view modelliert common_range, wenn

    Customization Point Objects

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

    Datenmitglieder

    Mitglied Beschreibung
    std:: tuple < Views... > views_ Alle angepassten View-Objekte
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

    Memberfunktionen

    		Konstruiert einen zip_view
    (Öffentliche Mitgliedsfunktion)
    		Gibt einen Iterator zum Anfang zurück
    (Öffentliche Mitgliedsfunktion)
    		Gibt einen Iterator oder Sentinel zum Ende zurück
    (Öffentliche Mitgliedsfunktion)
    		Gibt die Anzahl der Elemente zurück, bereitgestellt nur wenn jeder zugrundeliegende (adaptierte) Bereich sized_range erfüllt
    (Öffentliche Mitgliedsfunktion)
    Geerbt von 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 nte 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* )
    		der Sentinel-Typ, verwendet wenn zip_view kein common_range ist
    ( Nur zur Darstellung dienende Member-Klassenvorlage* )

    Hilfsvorlagen

    template < class ... Views >

    constexpr bool enable_borrowed_range < ranges :: zip_view < Views... >> =

    ( ranges:: enable_borrowed_range < Views > && ... ) ;
    		(seit C++23)

    Diese Spezialisierung von ranges::enable_borrowed_range bewirkt, dass zip_view das Konzept borrowed_range erfüllt, wenn jede zugrundeliegende View es erfüllt.

    Hinweise

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges_zip 202110L (C++23) ranges::zip_view ,
    ranges:: zip_transform_view ,
    ranges:: adjacent_view ,
    ranges:: adjacent_transform_view

    Beispiel

    Diesen Code ausführen 
    #include <array>
#include <iostream>
#include <list>
#include <ranges>
#include <string>
#include <tuple>
#include <vector>
void print(auto const rem, auto const& range)
{
    for (std::cout << rem; auto const& elem : range)
        std::cout << elem << ' ';
    std::cout << '\n';
}
int main()
{
    auto x = std::vector{1, 2, 3, 4};
    auto y = std::list<std::string>{"α", "β", "γ", "δ", "ε"};
    auto z = std::array{'A', 'B', 'C', 'D', 'E', 'F'};
    print("Quellansichten:", "");
    print("x: ", x);
    print("y: ", y);
    print("z: ", z);
    print("\nzip(x,y,z):", "");
    for (std::tuple<int&, std::string&, char&> elem : std::views::zip(x, y, z))
    {
        std::cout << std::get<0>(elem) << ' '
                  << std::get<1>(elem) << ' '
                  << std::get<2>(elem) << '\n';
        std::get<char&>(elem) += ('a' - 'A'); // modifiziert das Element von z
    }
    print("\nNach Modifikation, z: ", z);
}

    Ausgabe: 

    Quellansichten:
x: 1 2 3 4
y: α β γ δ ε
z: A B C D E F
zip(x,y,z):
1 α A
2 β B
3 γ C
4 δ D
Nach Modifikation, z: a b c d E F

    Siehe auch

    (C++23)
    		eine view bestehend aus Ergebnissen der Anwendung einer Transformationsfunktion auf entsprechende Elemente der adaptierten Views
    (Klassentemplate) (Customization Point Object)
    (C++20)
    		nimmt eine view bestehend aus tuple-like Werten und eine Zahl N und erzeugt eine view des N ten Elements jedes Tupels
    (Klassentemplate) (Range-Adaptor-Objekt)