Namespaces
Variants

    std::ranges::views::repeat, std::ranges::repeat_view

    Aus de.cppreference.net
     
    C++
     
    Ranges-Bibliothek
    Range-Adaptoren
     
    std::ranges::repeat_view
     
    Definiert in Header <ranges> 
    template< std::move_constructible W,
          std::semiregular Bound = std::unreachable_sentinel_t >
    requires (std::is_object_v<W> && std::same_as<W, std::remove_cv_t<W>> &&
             (/*integer-like-with-usable-difference-type*/<Bound> ||
              std::same_as<Bound, std::unreachable_sentinel_t>))
class repeat_view : public ranges::view_interface<repeat_view<W, Bound>>
    		(1) (seit C++23) 
    namespace views {
    inline constexpr /* unspecified */ repeat = /* unspecified */;
}
    		(2) (seit C++23)
    Aufrufsignatur
    		 
    template< class W >
    requires /* see below */
constexpr /* see below */ repeat( W&& value );
    		(seit C++23) 
    template< class W, class Bound >
    requires /* see below */
constexpr /* see below */ repeat( W&& value, Bound&& bound );
    		(seit C++23)
    Helfer-Konzepte
    		 
    concept /*integer-like-with-usable-difference-type*/ =
    /*is-signed-integer-like*/<T> ||
    (/*is-integer-like*/ <T> && std::weakly_incrementable<T>)
    		(3) (nur zur Veranschaulichung*)
    1) Eine Bereichsfabrik, die eine Folge von Elementen erzeugt, indem sie wiederholt denselben Wert produziert. Kann entweder begrenzt (bounded) oder unbegrenzt (unendlich) sein.
    2) views::repeat(e) und views::repeat(e, f) sind ausdrucksäquivalent zu repeat_view<std::decay_t<decltype((E))>>(e) bzw. repeat_view(e, f) für alle geeigneten Unterausdrücke e und f.
    3) Bestimmt, ob ein Typ integer-artig ist und einen verwendbaren Differenztyp hat.

    repeat_view modelliert random_access_range. Wenn Bound nicht std::unreachable_sentinel_t ist, modelliert repeat_view auch sized_range und common_range.

    Customization Point Objects

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

    Datenmitglieder

    Member Definition
    movable-box  < W > value_ das sich wiederholende Element der Ansicht
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )
    Bound bound_ der Sentinel-Wert
    ( Nur zur Darstellung verwendetes Mitgliedsobjekt* )

    Memberfunktionen

    		erstellt einen repeat_view
    (öffentliche Elementfunktion)
    		ermittelt den Beginn-Iterator eines repeat_view
    (öffentliche Elementfunktion)
    		ermittelt den Sentinel, der das Ende eines repeat_view kennzeichnet
    (öffentliche Elementfunktion)
    		ermittelt die Größe eines repeat_view falls dieser eine Größe besitzt
    (ö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 Mitgliedsfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen konstanten Iterator zum Anfang des Bereichs zurück
    (öffentliche Mitgliedsfunktion von std::ranges::view_interface<D>)
    (C++23)
    		 gibt einen Sentinel für den konstanten Iterator des Bereichs zurück
    (öffentliche Mitgliedsfunktion 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 Mitgliedsfunktion von std::ranges::view_interface<D>)
    		gibt das erste Element der abgeleiteten Ansicht zurück, bereitgestellt, wenn sie forward_range
    erfüllt (öffentliche Mitgliedsfunktion von std::ranges::view_interface<D>)
    		gibt das letzte Element der abgeleiteten Ansicht zurück, nur bereitgestellt, wenn sie bidirectional_range und common_range
    erfüllt (öffentliche Mitgliedsfunktion 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 Mitgliedsfunktion von std::ranges::view_interface<D>)

    std::ranges::repeat_view:: repeat_view

    repeat_view ( ) requires std:: default_initializable < W > = default ;
    		(1) (seit C++23)
    constexpr explicit repeat_view ( const W & value, Bound bound = Bound ( ) ) ;
    		(2) (seit C++23)
    constexpr explicit repeat_view ( W && value, Bound bound = Bound ( ) ) ;
    		(3) (seit C++23)
    template < class ... WArgs , class ... BoundArgs >

    requires std:: constructible_from < W, WArgs... >
    && std:: constructible_from < Bound, BoundArgs... >
    constexpr explicit
    repeat ( std:: piecewise_construct_t , std:: tuple < WArgs... > value_args,

    std:: tuple < BoundArgs... > bound_args = std:: tuple <> { } ) ;
    		(4) (seit C++23)
    1) Standard-initialisiert value_ und wert-initialisiert bound_ .
    2) Initialisiert value_ mit value und initialisiert bound_ mit bound .
    Wenn Bound nicht std::unreachable_sentinel_t ist und bool ( bound >= 0 ) false ist, ist das Verhalten undefiniert.
    3) Initialisiert value_ mit std :: move ( value ) und initialisiert bound_ mit bound .
    Wenn Bound nicht std::unreachable_sentinel_t ist und bool ( bound >= 0 ) false ist, ist das Verhalten undefiniert.
    4) Initialisiert value_ mit std:: make_from_tuple < T > ( std :: move ( value_args ) ) und bound_ mit std:: make_from_tuple < Bound > ( std :: move ( bound_args ) ) .
    Wenn Bound nicht std::unreachable_sentinel_t ist und bool ( bound >= 0 ) false ist, ist das Verhalten undefiniert.

    Parameter

    value - der wiederholt zu produzierende Wert
    bound - die Grenze
    value_args - das Tupel mit den Initialisierern von value_
    bound_args - das Tupel mit den Initialisierern von bound_

    std::ranges::repeat_view:: begin

    constexpr /*iterator*/ begin ( ) const ;
    		(seit C++23)

    Gibt iterator  ( std:: addressof ( * value_  ) ) zurück.

    std::ranges::repeat_view:: end

    constexpr /*iterator*/ end ( ) const
    requires ( ! std:: same_as < Bound, std:: unreachable_sentinel_t > ) ;
    		(1) (seit C++23)
    constexpr std:: unreachable_sentinel_t end ( ) const ;
    		(2) (seit C++23)
    1) Gibt zurück iterator  ( std:: addressof ( * value_  ) , bound_  ) .
    2) Gibt zurück std:: unreachable_sentinel .

    std::ranges::repeat_view:: size

    constexpr auto size ( ) const
    requires ( ! std:: same_as < Bound, std:: unreachable_sentinel_t > ) ;
    		(seit C++23)

    Gibt to-unsigned-like  ( bound_  ) zurück.

    **Übersetzungserläuterungen:** - "Returns" → "Gibt" (professionelle Übersetzung für Funktionsbeschreibungen) - "since C++23" → "seit C++23" (Standardübersetzung für Sprachversionen) - HTML-Tags, Attribute und Code-Blöcke wurden unverändert beibehalten - C++-spezifische Begriffe wie `constexpr`, `auto`, `size`, `requires`, `same_as`, `unreachable_sentinel_t` wurden nicht übersetzt - Die Formatierung und Struktur der originalen HTML-Seite wurde vollständig erhalten

    Deduktionsanleitungen

    template < class W, class Bound = std:: unreachable_sentinel_t >
    repeat_view ( W, Bound = Bound ( ) ) - > repeat_view < W, Bound > ;
    		(seit C++23)

    Geschachtelte Klassen

    		der Iteratortyp
    ( Nur zur Darstellung verwendete Memberklasse* )

    Hinweise

    Feature-Test Makro Wert Std Feature
    __cpp_lib_ranges_repeat 202207L (C++23) std::ranges::repeat_view

    Beispiel

    Diesen Code ausführen 
    #include <iostream>
#include <ranges>
#include <string_view>
using namespace std::literals;
int main()
{
    // bounded overload
    for (auto s : std::views::repeat("C++"sv, 3))
        std::cout << s << ' ';
    std::cout << '\n';
    // unbounded overload
    for (auto s : std::views::repeat("I know that you know that"sv)
                | std::views::take(3))
        std::cout << s << ' ';
    std::cout << "...\n";
}

    Ausgabe: 

    C++ C++ C++
I know that you know that I know that you know that I know that you know that ...

    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 4053 C++20 Unäre Aufrufe von views::repeat haben das Argument nicht zerfallen lassen Argument zerfallen lassen
    LWG 4054 C++20 Aufruf von views::repeat mit einem repeat_view
    hat keinen verschachtelten repeat_view erstellt     		erstellt einen verschachtelten
    repeat_view

    Siehe auch

    (C++20)
    		eine view bestehend aus einer Sequenz, die durch wiederholtes Inkrementieren eines Anfangswerts erzeugt wird
    (Klassentemplate) (Customization Point Object)