std:: basic_string_view

From cppreference.net

Definiert im Header `<string_view>`
template < class CharT, class Traits = std:: char_traits < CharT > > class basic_string_view ;		(seit C++17)

Die Klassenvorlage basic_string_view beschreibt ein Objekt, das auf eine konstante zusammenhängende Sequenz von CharT verweisen kann, wobei sich das erste Element der Sequenz an Position null befindet.

Für einen basic_string_view str werden Zeiger, Iteratoren und Referenzen auf Elemente von str ungültig, wenn eine Operation einen Zeiger im Bereich [ str. data ( ) , str. data ( ) + str. size ( ) ) ungültig macht.

Jede Spezialisierung von std::basic_string_view ist ein TriviallyCopyable Typ.

(since C++23)

Es werden mehrere Typdefinitionen für gängige Zeichentypen bereitgestellt:

Definiert im Header `<string_view>`
Typ	Definition
std::string_view (C++17)	std :: basic_string_view < char >
std::wstring_view (C++17)	std :: basic_string_view < wchar_t >
std::u8string_view (C++20)	std :: basic_string_view < char8_t >
std::u16string_view (C++17)	std :: basic_string_view < char16_t >
std::u32string_view (C++17)	std :: basic_string_view < char32_t >

Inhaltsverzeichnis

Template-Parameter

CharT	-	Zeichentyp
Traits	-	CharTraits Klasse, die die Operationen für den Zeichentyp spezifiziert. Wie bei std::basic_string muss `Traits::char_type` denselben Typ wie `CharT` bezeichnen, andernfalls ist das Programm fehlerhaft.

Geschachtelte Typen

Typ Definition

traits_type Traits

value_type CharT

pointer CharT *

const_pointer const CharT *

reference CharT &

const_reference const CharT &


          const_iterator

implementierungsdefinierter konstanter LegacyRandomAccessIterator ,

und LegacyContiguousIterator	(bis C++20)
ConstexprIterator , und `contiguous_iterator`	(seit C++20)

dessen value_type CharT ist

iterator const_iterator

const_reverse_iterator std:: reverse_iterator < const_iterator >

reverse_iterator const_reverse_iterator

size_type std::size_t

difference_type std::ptrdiff_t

Hinweis: iterator und const_iterator sind der gleiche Typ, da String-Views Ansichten in konstante Zeichensequenzen sind.

Alle Anforderungen an die Iteratortypen eines Container gelten ebenfalls für die iterator - und const_iterator -Typen von basic_string_view .

Datenmitglieder

Mitglied	Beschreibung
`const_pointer` `data_`	ein Zeiger auf die zugrundeliegende Sequenz ( Nur-Darstellungs-Mitgliedsobjekt* )
`size_type` `size_`	die Anzahl der Zeichen ( Nur-Darstellungs-Mitgliedsobjekt* )

Memberfunktionen

Konstruktoren und Zuweisung
(constructor)	Konstruiert einen `basic_string_view` (öffentliche Elementfunktion)
operator=	weist eine Ansicht zu (öffentliche Elementfunktion)
Iteratoren
begin cbegin	gibt einen Iterator zum Anfang zurück (öffentliche Elementfunktion)
end cend	gibt einen Iterator zum Ende zurück (öffentliche Member-Funktion)
rbegin crbegin	gibt einen Reverse-Iterator zum Anfang zurück (öffentliche Member-Funktion)
rend crend	gibt einen umgekehrten Iterator zum Ende zurück (öffentliche Elementfunktion)
Elementzugriff
operator[]	greift auf das angegebene Zeichen zu (öffentliche Elementfunktion)
at	greift auf das angegebene Zeichen mit Grenzprüfung zu (öffentliche Elementfunktion)
front	greift auf das erste Zeichen zu (öffentliche Elementfunktion)
back	greift auf das letzte Zeichen zu (öffentliche Elementfunktion)
data	gibt einen Zeiger auf das erste Zeichen der Ansicht zurück (öffentliche Elementfunktion)
Kapazität
size length	gibt die Anzahl der Zeichen zurück (öffentliche Elementfunktion)
max_size	gibt die maximale Anzahl von Zeichen zurück (öffentliche Elementfunktion)
empty	prüft, ob die Ansicht leer ist (öffentliche Elementfunktion)
Modifikatoren
remove_prefix	verkleinert die Ansicht, indem der Start nach vorne verschoben wird (öffentliche Elementfunktion)
remove_suffix	verkleinert die Ansicht, indem das Ende nach hinten verschoben wird (öffentliche Elementfunktion)
swap	tauscht die Inhalte aus (öffentliche Elementfunktion)
Operationen
copy	kopiert Zeichen (öffentliche Elementfunktion)
substr	gibt einen Teilstring zurück (öffentliche Elementfunktion)
compare	vergleicht zwei Views (öffentliche Elementfunktion)
starts_with (C++20)	prüft, ob die String-View mit dem angegebenen Präfix beginnt (öffentliche Elementfunktion)
ends_with (C++20)	prüft, ob die String-View mit dem angegebenen Suffix endet (öffentliche Elementfunktion)
contains (C++23)	prüft, ob die String-View die gegebene Teilzeichenkette oder das Zeichen enthält (öffentliche Elementfunktion)
find	Zeichen in der Ansicht finden (öffentliche Elementfunktion)
rfind	finde das letzte Vorkommen eines Teilstrings (öffentliche Elementfunktion)
find_first_of	findet erstes Vorkommen von Zeichen (öffentliche Elementfunktion)
find_last_of	Suche letztes Vorkommen von Zeichen (öffentliche Elementfunktion)
find_first_not_of	Finden der ersten Abwesenheit von Zeichen (öffentliche Elementfunktion)
find_last_not_of	Suche letztes Nichtvorkommen von Zeichen (öffentliche Elementfunktion)
Konstanten
npos [static]	Spezialwert. Die genaue Bedeutung hängt vom Kontext ab (öffentliche statische Member-Konstante)

Nicht-Member-Funktionen

operator== operator!= operator< operator> operator<= operator>= operator<=> (C++17) (entfernt in C++20) (entfernt in C++20) (entfernt in C++20) (entfernt in C++20) (entfernt in C++20) (C++20)	vergleicht zwei String-Views lexikographisch (Funktionstemplate)
Eingabe/Ausgabe
operator<< (C++17)	führt Stream-Ausgabe für String-Views durch (Funktionstemplate)

Literale

Definiert im Inline-Namensraum `std::literals::string_view_literals`
operator""sv (C++17)	erstellt einen String-View eines Zeichenarray-Literals (Funktion)

Hilfsklassen

std::hash <std::string_view> std::hash <std::wstring_view> std::hash <std::u8string_view> std::hash <std::u16string_view> std::hash <std::u32string_view>

(C++17) (C++17) (C++20) (C++17) (C++17)

Hash-Unterstützung für String-Views
(Klassen-Template-Spezialisierung)

Hilfsvorlagen

template < class CharT, class Traits > inline constexpr bool ranges:: enable_borrowed_range < std :: basic_string_view < CharT, Traits >> = true ;		(seit C++20)

Diese Spezialisierung von ranges::enable_borrowed_range bewirkt, dass basic_string_view die Anforderungen von borrowed_range erfüllt.

template < class CharT, class Traits > inline constexpr bool ranges:: enable_view < std :: basic_string_view < CharT, Traits >> = true ;		(seit C++20)

Diese Spezialisierung von ranges::enable_view bewirkt, dass basic_string_view die Anforderungen von view erfüllt.

Deduktionsanleitungen

(seit C++20)

Hinweise

Es ist die Verantwortung des Programmierers, sicherzustellen, dass std::string_view nicht länger existiert als das zugrunde liegende Zeichenarray:

std::string_view good{"a string literal"};
    // "Guter" Fall: `good` zeigt auf ein statisches Array.
    // Zeichenkettenliterale befinden sich im persistenten Datenspeicher.
std::string_view bad{"a temporary string"s};
    // "Schlechter" Fall: `bad` enthält einen hängenden Zeiger, da das std::string-Temporary,
    // erstellt durch std::operator""s, am Ende der Anweisung zerstört wird.

Spezialisierungen von std::basic_string_view sind bereits in allen existierenden Implementierungen trivial kopierbare Typen, selbst vor der formalen Anforderung, die in C++23 eingeführt wurde.

Feature-Test Makro	Wert	Standard	Funktion
`__cpp_lib_string_view`	`201606L`	(C++17)	`std::string_view`
`__cpp_lib_string_view`	`201803L`	(C++20)	ConstexprIterator
`__cpp_lib_string_contains`	`202011L`	(C++23)	`contains`

Beispiel

Diesen Code ausführen

#include <iostream>
#include <string_view>
int main()
{
    #define A "▀"
    #define B "▄"
    #define C "─"
    constexpr std::string_view blocks[]{A B C, B A C, A C B, B C A};
    for (int y{}, p{}; y != 8; ++y, p = ((p + 1) % 4))
    {
        for (char x{}; x != 29; ++x)
            std::cout << blocks[p];
        std::cout << '\n';
    }
}

Ausgabe:

▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─
▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─
▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄
▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀
▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─
▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─
▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄
▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀

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 3203	C++17	Nur Zeiger, Iteratoren und Referenzen die von Memberfunktionen von `basic_string_view` zurückgegeben werden, könnten ungültig werden	Alle Zeiger, Iteratoren und Referenzen auf Elemente von `basic_string_view` können ungültig werden

Siehe auch

basic_string	speichert und manipuliert Zeichenfolgen (Klassentemplate)
operator+	verkettet zwei Strings, einen String und ein char , oder einen String und ein string_view (Funktionstemplate)
span (C++20)	eine nicht-besitzende Ansicht über eine zusammenhängende Objektsequenz (Klassentemplate)
initializer_list (C++11)	referenziert ein temporäres Array, das bei Listeninitialisierung erstellt wird (Klassentemplate)

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants

std:: basic_string_view

Inhaltsverzeichnis

Template-Parameter

Geschachtelte Typen

Datenmitglieder

Memberfunktionen

Konstruktoren und Zuweisung

Iteratoren

Elementzugriff

Kapazität

Modifikatoren

Operationen

Konstanten