Namespaces
Variants

    std::ranges::views::join_with, std::ranges::join_with_view

    Von de.cppreference.net
     
    C++
     
    Bereichsbibliothek
    Bereichsadaptoren
     
    std::ranges::join_with_view
     
    Definiert in Header <ranges> 
    template< ranges::input_range V, ranges::forward_range Pattern >
  requires ranges::view<V> &&
           ranges::input_range<ranges::range_reference_t<V>> &&
           ranges::view<Pattern> &&
           /*concatable*/<ranges::range_reference_t<V>, Pattern>
class join_with_view : 
    ranges::view_interface<join_with_view<V, Pattern>>
    		(1) (seit C++23) 
    namespace views {
    inline constexpr /* unspecified */ join_with = /* unspecified */;
}
    		(2) (seit C++23)
    Aufrufsignatur
    		 
    template< ranges::viewable_range R, class Pattern >
    requires /* see below */
constexpr ranges::view auto join_with( R&& r, Pattern&& pattern );
    		(seit C++23) 
    template< class Pattern >
constexpr /* range adaptor closure */ join_with( Pattern&& pattern );
    		(seit C++23)
    1) Ein Bereichsadaptor, der eine view darstellt, die aus der Sequenz besteht, die durch Abflachen einer Ansicht von Bereichen erhalten wird, wobei jedes Element des Trennzeichens zwischen die Elemente der Ansicht eingefügt wird. Das Trennzeichen kann ein einzelnes Element oder eine Ansicht von Elementen sein.
    Für die Definition von /*concatable*/ siehe std::ranges::concat_view.
    2) RangeAdaptorObject. Der Ausdruck views::join_with(e, f) ist ausdrucksäquivalent zu join_with_view(e, f) für alle geeigneten Unterausdrücke e und f.

    join_with_view modelliert input_range.

    join_with_view modelliert forward_range, wenn:

    • ranges::range_reference_t<V> eine Referenz ist, und
    • V und ranges::range_reference_t<V> jeweils forward_range modellieren.

    join_with_view modelliert bidirectional_range, wenn:

    • ranges::range_reference_t<V> eine Referenz ist,
    • V, ranges::range_reference_t<V>, und Pattern jeweils bidirectional_range modellieren, und
    • ranges::range_reference_t<V> und Pattern jeweils common_range modellieren.

    join_with_view modelliert common_range, wenn:

    • ranges::range_reference_t<V> eine Referenz ist, und
    • V und ranges::range_reference_t<V> jeweils forward_range und common_range modellieren.

    Verschachtelte Typen

    Typ Definition
    InnerRng ranges:: range_reference_t < V >
    ( Nur zur Darstellung verwendeter Member-Typ* )

    Datenelemente

    Element Beschreibung
    V base_ die zugrunde liegende (angepasste) Ansicht
    (nur zur Erläuterung dienendes Elementobjekt*)
    Pattern pattern_ das Musterobjekt
    (nur zur Erläuterung dienendes Elementobjekt*)
    non-propagating-cache <ranges::iterator_t<V>> outer_it_
    (nur vorhanden, wenn V das Konzept forward_range nicht modelliert)     		der Cache des äußeren Iterators
    (nur zur Erläuterung dienendes Elementobjekt*)
    non-propagating-cache <std::remove_cv_t<InnerRng >> inner_
    (nur vorhanden, wenn std::is_reference_v<InnerRng > false ist)     		der Cache des inneren Bereichs
    (nur zur Erläuterung dienendes Elementobjekt*)

    Memberfunktionen

    		erstellt einen join_with_view
    (öffentliche Elementfunktion)
    		gibt eine Kopie der zugrundeliegenden (adaptierten) Ansicht zurück
    (öffentliche Elementfunktion)
    		gibt einen Iterator zum Anfang zurück
    (öffentliche Elementfunktion)
    		gibt einen Iterator oder Sentinel zum Ende zurück
    (öffentliche Elementfunktion)
    Geerbt von ranges::view_interface
    		gibt zurück, ob die abgeleitete View leer ist, nur verfügbar, 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 der Range zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator der Range zurück
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt zurück, ob die abgeleitete View nicht leer ist, nur verfügbar, wenn ranges::empty darauf anwendbar ist
    (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element in der abgeleiteten View zurück, verfügbar, wenn sie forward_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element in der abgeleiteten View zurück, nur verfügbar, wenn sie bidirectional_range und common_range
    erfüllt (öffentliche Elementfunktion von std::ranges::view_interface<D>)

    Ableitungsleitfäden

    Geschachtelte Klassen

    		der Iteratortyp
    ( Nur zur Darstellung dienende Member-Klassentemplate* )
    		der Sentineltyp
    ( Nur zur Darstellung dienende Member-Klassentemplate* )

    Hinweise

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges_join_with 202202L (C++23) std::ranges::join_with_view

    Beispiel

    Diesen Code ausführen 
    #include <iostream>
#include <ranges>
#include <string_view>
#include <vector>
int main()
{
    using namespace std::literals;
    std::vector v{"This"sv, "is"sv, "a"sv, "test."sv};
    auto joined = v | std::views::join_with(' ');
    for (auto c : joined)
        std::cout << c;
    std::cout << '\n';
}

    Ausgabe: 

    This is a test.

    Fehlerberichte

    Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

    DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
    LWG 4074 C++23 join_with_view war unterbeschränkt Einschränkungen aktualisiert

    Siehe auch

    (C++20)
    		eine view bestehend aus der durch Aufflatten einer view von range s erhaltenen Sequenz
    (Klassentemplate) (Range-Adapter-Objekt)
    (C++26)
    		eine view bestehend aus der Verkettung der adaptierten Views
    (Klassentemplate) (Customization-Point-Objekt)