Namespaces
Variants

    std::ranges::views::zip_transform, std::ranges::zip_transform_view

    Von de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Range-Adaptoren
     
    std::ranges::zip_transform_view
    Mitgliedsfunktionen
    Deduktionshilfen
    Iterator
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
    Sentinel
    Mitgliedsfunktionen
    Nicht-Mitgliedsfunktionen
     
    Definiert in Header <ranges> 
    template< std::move_constructible F, ranges::input_range... Views >
    requires (ranges::view<Views> && ...) && (sizeof...(Views) > 0) &&
              std::is_object_v<F> && std::regular_invocable<
                  F&, ranges::range_reference_t<Views>...> &&
              /*can-reference*/<std::invoke_result_t<
                  F&, ranges::range_reference_t<Views>...>>
class zip_transform_view
     : public ranges::view_interface<zip_transform_view<F, Views...>>
    		(1) (seit C++23) 
    namespace views {
    inline constexpr /*unspecified*/ zip_transform = /*unspecified*/;
}
    		(2) (seit C++23)
    Aufrufsignatur
    		 
    template< class F, ranges::viewable_range... Rs >
    requires /* see below */
constexpr auto zip_transform( F&& f, Rs&&... rs );
    		(seit C++23)
    1) zip_transform_view ist ein Range-Adaptor, der ein aufrufbares Objekt und einen oder mehrere views nimmt und einen view erzeugt, dessen ites Element das Ergebnis der Anwendung des aufrufbaren Objekts auf die iten Elemente aller views ist.
    Ein Typ T modelliert das exposition-only-Konzept /*can-reference*/ genau dann, wenn T& ein gültiger Typ ist.
    2) views::zip_transform ist ein Customization-Point-Objekt.

    Wenn mit einem Argument f aufgerufen, sei FD gleich std::decay_t<decltype(f)>, falls:

    dann ist views::zip_transform(f) ausdrucksäquivalent zu ((void)f, auto(views::empty<std::decay_t<std::invoke_result_t<FD&>>>)). Andernfalls ist der Aufruf von views::zip_transform fehlerhaft.

    Wenn mit mehr als einem Argument f und rs... aufgerufen, ist views::zip_transform(f, rs...) ausdrucksäquivalent zu ranges::zip_transform_view(f, rs...).

    zip_transform_view modelliert die Konzepte random_access_range, bidirectional_range, forward_range, input_range, common_range und sized_range, wenn der zugrundeliegende ranges::zip_view<Views...> die entsprechenden Konzepte modelliert.

    Customization Point Objects

    Der Name views::zip_transform bezeichnet ein Customization Point Object , welches ein konstantes Funktionsobjekt eines Literal semiregular Klassentyps ist. Siehe CustomizationPointObject für Details.

    Memberfunktionen

    		Konstruiert einen zip_transform_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 jeder zugrundeliegende (adaptierte) Bereich sized_range erfüllt
    (Öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete Ansicht leer ist, nur bereitgestellt, wenn sie sized_range oder forward_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Beginn 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 bereitgestellt, 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, nur bereitgestellt, 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, nur bereitgestellt, wenn sie random_access_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)

    Ableitungsleitfäden

    Mitgliedstypen

    Typ Definition
    InnerView (privat) ranges::zip_view<Views...>.
    (Nur zur Darstellung dienender Mitgliedstyp*)
    ziperator (privat)
    • ranges::iterator_t<const InnerView> falls Const true ist, andernfalls
    • ranges::iterator_t<InnerView>.
      (Nur zur Darstellung dienender Mitgliedstyp*)
    zentinel (privat)
    • ranges::sentinel_t<const InnerView> falls Const true ist, andernfalls
    • ranges::sentinel_t<InnerView>.
      (Nur zur Darstellung dienender Mitgliedstyp*)

    Datenelemente

    Element Beschreibung
    InnerView zip_ (privat) ein zugrunde liegendes View-Objekt
    (nur zur Darstellung dienendes Member-Objekt*)
    bewegbare Box<F> fun_ (privat) ein eingewickeltes aufrufbares Objekt
    (nur zur Darstellung dienendes Member-Objekt*)

    Geschachtelte Klassen

    		der Iteratortyp
    ( Nur zur Darstellung verwendete Member-Klassenvorlage* )
    		der Sentinel-Typ, verwendet wenn der zugrundeliegende zip_view kein common_range ist
    ( Nur zur Darstellung verwendete Member-Klassenvorlage* )

    Hinweise

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges_zip 202110L (C++23) ranges:: zip_view ,
    std::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 <vector>
void print(auto const rem, auto const& r)
{
    std::cout << rem << '{'; 
    for (char o[]{0,' ',0}; auto const& e : r)
        std::cout << o << e, *o = ',';
    std::cout << "}\n";
}
int main()
{
    auto v1 = std::vector<float>{1, 2, 3};
    auto v2 = std::list<short>{1, 2, 3, 4};
    auto v3 = std::to_array({1, 2, 3, 4, 5});
    auto add = [](auto a, auto b, auto c) { return a + b + c; };
    auto sum = std::views::zip_transform(add, v1, v2, v3);
    print("v1:  ", v1);
    print("v2:  ", v2);
    print("v3:  ", v3);
    print("sum: ", sum);
}

    Ausgabe: 

    v1:  {1, 2, 3}
v2:  {1, 2, 3, 4}
v3:  {1, 2, 3, 4, 5}
sum: {3, 6, 9}

    Siehe auch

    (C++23)
    		 eine Ansicht, die aus Tupeln von Referenzen auf entsprechende Elemente der angepassten Ansichten besteht
    (Klassenschablone) (Anpassungspunktobjekt)
    (C++20)
    		 eine Ansicht einer Sequenz, die eine Transformationsfunktion auf jedes Element anwendet
    (Klassenschablone) (Bereichsanpassungsobjekt)
    (C++20)
    		 nimmt eine Ansicht bestehend aus tupelartigen Werten und einer Zahl N und erzeugt eine Ansicht des N-ten Elements jedes Tupels
    (Klassenschablone) (Bereichsanpassungsobjekt)