Namespaces
Variants

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

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::repeat_view
Definiert im 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 /* nicht spezifiziert */ repeat = /* nicht spezifiziert */ ;

}
(2) (seit C++23)
Aufrufsignatur
template < class W >

requires /* siehe unten */

constexpr /* siehe unten */ repeat ( W && value ) ;
(seit C++23)
template < class W, class Bound >

requires /* siehe unten */

constexpr /* siehe unten */ repeat ( W && value, Bound && bound ) ;
(seit C++23)
Hilfskonzepte
concept /*integer-like-with-usable-difference-type*/ =

/*is-signed-integer-like*/ < T > ||

( /*is-integer-like*/ < T > && std:: weakly_incrementable < T > )
(3) ( nur zur Darstellung* )
1) Eine Bereichsfabrik, die eine Sequenz von Elementen erzeugt, indem sie wiederholt denselben Wert produziert. Kann entweder begrenzt 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 ) und repeat_view ( e, f ) jeweils für beliebige geeignete Teilausdrücke e und f .
3) Bestimmt, ob ein Typ integer-like ist und einen verwendbaren difference type besitzt.

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

Inhaltsverzeichnis

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 std::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 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, 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 falls 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 n -te Element in der abgeleiteten Ansicht zurück, bereitgestellt nur wenn sie random_access_range erfüllt
(öffentliche Elementfunktion 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)