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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bereichsbibliothek

Bereichszugriff begin cbegin   end cend rbegin crbegin   rend crend size ssize   data cdata reserve_hint (C++26)   empty

Range-Konvertierungen std::from_range_t std::from_range (C++23)(C++23)     to (C++23)

Behandlung von hängenden Iteratoren dangling borrowed_iterator_t borrowed_subrange_t

Range-Primitive
range_size_trange_difference_trange_value_t elements_of (C++23)	iterator_tconst_iterator_tsentinel_tconst_sentinel_t (C++23)(C++23)	range_reference_trange_const_reference_trange_rvalue_reference_trange_common_reference_t (C++23)

Range-Konzepte
range borrowed_range    common_range	sized_range viewable_range    view	input_range output_range forward_range	bidirectional_range    random_access_range contiguous_range	approximately_sized_range (C++26) constant_range (C++23)

Ansichten
view_interface	subrange

Range-Fabriken
empty_viewviews::empty	single_viewviews::single	basic_istream_viewviews::istream	iota_viewviews::iota	repeat_viewviews::repeat (C++23)(C++23)

Range-Adaptoren
views::all_tviews::all as_rvalue_viewviews::as_rvalue (C++23)(C++23)   filter_viewviews::filter transform_viewviews::transform take_viewviews::take take_while_viewviews::take_while common_viewviews::common views::counted to_input_viewviews::to_input (C++26)(C++26)	ref_view drop_viewviews::drop drop_while_viewviews::drop_while lazy_split_viewviews::lazy_split split_viewviews::split join_viewviews::join join_with_viewviews::join_with (C++23)(C++23)   concat_viewviews::concat (C++26)(C++26) cache_latest_viewviews::cache_latest (C++26)(C++26)	owning_view reverse_viewviews::reverse as_const_viewviews::as_const (C++23)(C++23) elements_viewviews::elements keys_viewviews::keys values_viewviews::values enumerate_viewviews::enumerate (C++23)(C++23) zip_viewviews::zip (C++23)(C++23) zip_transform_viewviews::zip_transform (C++23)(C++23)	adjacent_viewviews::adjacent (C++23)(C++23) views::pairwise (C++23) adjacent_transform_viewviews::adjacent_transform (C++23)(C++23) views::pairwise_transform (C++23) chunk_viewviews::chunk (C++23)(C++23) slide_viewviews::slide (C++23)(C++23) chunk_by_viewviews::chunk_by (C++23)(C++23) stride_viewviews::stride (C++23)(C++23) cartesian_product_viewviews::cartesian_product (C++23)(C++23)

Range generators std::generator (C++23)

Range-Adaptor-Closure-Objekte range_adaptor_closure (C++23)

Range-Adaptor-Objekte

Hilfselemente
copyable-box movable-box (bis C++23)  (C++23)	simple-view non-propagating-cache

 

std::ranges::repeat_view

Memberfunktionen

repeat_view::repeat_view

repeat_view::begin

repeat_view::end

repeat_view::size

Deduction Guides

Iterator

Memberfunktionen

repeat_view::iterator::iterator

repeat_view::iterator::operator*

repeat_view::iterator::operator[]

repeat_view::iterator::operator++ repeat_view::iterator::operator++(int)

repeat_view::iterator::operator-- repeat_view::iterator::operator--(int)

repeat_view::iterator::operator+=

repeat_view::iterator::operator-=

Nicht-Member-Funktionen

operator==(repeat_view::iterator) operator<=>(repeat_view::iterator)

operator+(repeat_view::iterator)

operator-(repeat_view::iterator)

 

Definiert in der Header-Datei <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)
Aufruf-Signatur
template< class W >     requires /* siehe unten */ constexpr /* see below */ repeat( W&& value );		(seit C++23)
template< class W, class Bound >     requires /* siehe unten */ constexpr /* see below */ 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 Exposition*)

1) Eine Bereichsfabrik, die eine Sequenz von Elementen erzeugt, indem derselbe Wert wiederholt ausgegeben wird. Kann 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 Unterausdrücke e und f.

3) Ermittelt, ob ein Typ integer-like ist und einen verwendbaren difference type 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, ein konstantes Funktionsobjekt vom Literal semiregular-Klassentyp. Zu Aus exposiçãostechnischen Zwecken wird die cv-unqualifizierte Version seines Typs als __repeat_fn bezeichnet.

Alle Instanzen von __repeat_fn sind gleich. Die Auswirkungen des Aufrufs verschiedener Instanzen vom Typ __repeat_fn mit denselben Argumenten sind äquivalent, unabhängig davon, ob der Ausdruck, der die Instanz bezeichnet, ein lvalue oder rvalue ist, und ob er const-qualifiziert ist oder nicht (eine volatile-qualifizierte Instanz muss jedoch nicht aufrufbar sein). Daher kann views::repeat frei kopiert und seine Kopien können austauschbar verwendet werden.

Gegeben eine Menge von Typen Args..., wenn std::declval<Args>()... die Anforderungen an Argumente von views::repeat oben erfüllen, modelliert __repeat_fn

• std::invocable<__repeat_fn, Args...>,
• std::invocable<const __repeat_fn, Args...>,
• std::invocable<__repeat_fn&, Args...>
• std::invocable<const __repeat_fn&, Args...>.
  

Andernfalls nimmt kein Funktionsaufrufoperator von __repeat_fn an der Überladungsauflösung teil.

Datenmitglieder

Mitglied	Definition
movable-box <W> value_	das sich wiederholende Element der Ansicht ((exposition-only member object*)
Bound bound_	der Sentinel-Wert ((exposition-only member object*)

Memberfunktionen

(Konstruktor)	erzeugt eine repeat_view (öffentliche Memberfunktion)
begin	erhält den Anfangs-Iterator einer repeat_view (öffentliche Memberfunktion)
end	erhält den Sentinel, der das Ende einer repeat_view bezeichnet (öffentliche Memberfunktion)
size	erhält die Größe einer repeat_view, wenn diese sized ist (öffentliche Memberfunktion)
Geerbt von std::ranges::view_interface
empty	gibt zurück, ob die abgeleitete Ansicht leer ist, bereitgestellt nur, wenn sie sized_range oder forward_range erfüllt (public member function of std::ranges::view_interface<D>)
cbegin (C++23)	gibt einen konstanten Iterator zum Anfang des Bereichs zurück (public member function of std::ranges::view_interface<D>)
cend (C++23)	gibt ein Sentinel für den konstanten Iterator des Bereichs zurück (public member function of std::ranges::view_interface<D>)
operator bool	gibt zurück, ob die abgeleitete Ansicht nicht leer ist, bereitgestellt nur, wenn ranges::empty darauf anwendbar ist (public member function of std::ranges::view_interface<D>)
front	gibt das erste Element in der abgeleiteten View zurück, bereitgestellt, wenn sie forward_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
back	gibt das letzte Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie bidirectional_range und common_range erfüllt (öffentliche Member-Funktion von std::ranges::view_interface<D>)
operator[]	gibt das n-te Element in der abgeleiteten View zurück, nur bereitgestellt, wenn sie random_access_range erfüllt (öffentliche Member-Funktion 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) Initialisiert value_ per default und bound_ per Wertinitialisierung.

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 auszugebende Wert
bound	-	die Grenze
value_args	-	das Tupel, das die Initialisierer von value_ enthält
bound_args	-	das Tupel, das die Initialisierer von bound_ enthält

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 iterator (std::addressof(*value_ ), bound_ ) zurück.

2) Gibt std::unreachable_sentinel zurück.

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.

Deduktionsführer

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

Verschachtelte Klassen

iterator

der Iterator-Typ ((nur zur Veranschaulichung)*)

Hinweise

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

Beispiel

Führen Sie diesen Code aus

#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 ...

Defect reports

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

DR	angewendet auf	Verhalten wie veröffentlicht	Korrigiertes Verhalten
LWG 4053	C++20	unäre Aufrufe von views::repeat haben das Argument nicht dekodiert	das Argument dekodieren
LWG 4054	C++20	Aufruf von views::repeat mit einer repeat_view erzeugte keine verschachtelte repeat_view	erzeugt eine verschachtelte repeat_view

Siehe auch

ranges::iota_viewviews::iota (C++20)

ein view, der eine Sequenz aus aufeinanderfolgenden Inkrementierungen eines Anfangswerts besteht (Klassen-Template) (Customization Point Objekt)