Namespaces
Variants

std::ranges:: views:: common, std::ranges:: common_view

From cppreference.net
C++
Ranges library
Range adaptors
std::ranges::common_view
Definiert im Header <ranges>
template < ranges:: view V >

requires ( not ranges:: common_range < V > and
std:: copyable < ranges:: iterator_t < V >> )
class common_view

: public ranges:: view_interface < common_view < V >>
(1) (seit C++20)
namespace views {

inline constexpr /* nicht spezifiziert */ common = /* nicht spezifiziert */ ;

}
(2) (seit C++20)
Aufrufsignatur
template < ranges:: viewable_range R >

requires /* siehe unten */

constexpr ranges:: view auto common ( R && r ) ;
(seit C++20)
1) Passt eine gegebene view mit unterschiedlichen Typen für Iterator/Sentinel-Paar an eine view an, die ebenfalls ein common_range ist. Ein common_view hat immer denselben Iterator/Sentinel-Typ.
2) RangeAdaptorObject . Sei e ein Subausdruck. Dann ist der Ausdruck views :: common ( e ) ausdrucksäquivalent zu:
  • views:: all ( e ) , falls dies ein wohldefinierter Ausdruck ist und decltype ( ( e ) ) das Konzept common_range modelliert;
  • common_view { e } andernfalls.

Inhaltsverzeichnis

Datenmitglieder

Mitglied Beschreibung
V base_ (privat) die zugrundeliegende Ansicht
( Nur-Darstellungs-Mitgliedsobjekt* )

Memberfunktionen

konstruiert einen common_view
(öffentliche Elementfunktion)
gibt eine Kopie der zugrundeliegenden (angepassten) Ansicht zurück
(öffentliche Elementfunktion)
gibt einen Iterator zum Anfang zurück
(öffentliche Elementfunktion)
gibt einen Iterator zum Ende zurück
(öffentliche Elementfunktion)
gibt die Anzahl der Elemente zurück, bereitgestellt nur wenn der zugrundeliegende (angepasste) Bereich sized_range erfüllt
(öffentliche Elementfunktion)
(C++26)
gibt die ungefähre Größe des resultierenden approximately_sized_range zurück
(ö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 Anfang 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> )
ruft die Adresse der Daten der abgeleiteten Ansicht ab, bereitgestellt nur wenn ihr Iteratortyp contiguous_iterator erfüllt
(ö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, 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> )

Deduktionshilfen

Hilfsvorlagen

template < class T >

constexpr bool enable_borrowed_range < std :: ranges :: common_view < T >> =

ranges:: enable_borrowed_range < T > ;
(seit C++20)

Diese Spezialisierung von ranges::enable_borrowed_range bewirkt, dass common_view borrowed_range erfüllt, wenn die zugrundeliegende View diese Bedingung erfüllt.

Hinweise

common_view kann nützlich sein für die Arbeit mit Legacy-Algorithmen, die erwarten, dass Iterator und Sentinel denselben Typ haben.

Beispiel

Diesen Code ausführen 
#include <initializer_list>
#include <iostream>
#include <iterator>
#include <list>
#include <numeric>
#include <ranges>
int main()
{
    auto v1 = {1, 2, 3, 4, 5};
    auto i1 = std::counted_iterator{v1.begin(), std::ssize(v1)};
    auto r1 = std::ranges::subrange{i1, std::default_sentinel};
//  auto e1 = std::accumulate(r1.begin(), r1.end(), 0); // Fehler: "common range" erforderlich
    auto c1 = std::ranges::common_view{r1};
    std::cout << "accumulate: " << std::accumulate(c1.begin(), c1.end(), 0) << '\n';
    // geerbt von ranges::view_interface:
    std::cout << "c1.front(): " << c1.front() << '\n';
    std::cout << "c1.back(): " << c1.back() << '\n';
    std::cout << "c1.data(): " << c1.data() << '\n';
    std::cout << "c1[0]: " << c1[0] << '\n';
    auto v2 = std::list{1, 2, 3, 4, 5};
    auto i2 = std::counted_iterator{v2.begin(), std::ssize(v2)};
    auto r2 = std::ranges::subrange{i2, std::default_sentinel};
//  auto e2 = std::accumulate(r2.begin(), r2.end(), 0); // Fehler: "common range" erforderlich
    auto c2 = std::ranges::common_view{ r2 };
    std::cout << "accumulate: " << std::accumulate(c2.begin(), c2.end(), 0) << '\n';
    // geerbt von ranges::view_interface:
    std::cout << "c2.front(): " << c2.front() << '\n';
//  auto e3 = c2.back(); // Fehler: "bidirectional range" erforderlich
//  auto e4 = c2.data(); // Fehler: "contiguous range" erforderlich
//  auto e5 = c2[0];     // Fehler: "random access range" erforderlich
}

Mögliche Ausgabe: 

accumulate: 15
c1.front(): 1
c1.back(): 5
c1.data(): 0x7f19937f00d0
c1[0]: 1
accumulate: 15
c2.front(): 1

Fehlerberichte

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 3494 C++20 common_view war nie ein borrowed_range es ist ein borrowed_range wenn seine zugrunde liegende Ansicht es ist

Siehe auch

(C++20)
spezifiziert, dass ein Range identische Iterator- und Sentinel-Typen besitzt
(Konzept)
(C++20)
passt einen Iterator-Typ und seinen Sentinel an einen gemeinsamen Iterator-Typ an
(Klassentemplate)