std::basic_string_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

 

Bibliothek für Zeichenketten

Klassen

basic_string

basic_string_view (C++17)

char_traits

 

std::basic_string_view

Memberfunktionen basic_string_view::basic_string_view    basic_string_view::operator= Iteratoren basic_string_view::beginbasic_string_view::cbegin basic_string_view::endbasic_string_view::cend basic_string_view::rbeginbasic_string_view::crbegin basic_string_view::rendbasic_string_view::crend Kapazität basic_string_view::sizebasic_string_view::length basic_string_view::max_size basic_string_view::empty Operationen basic_string_view::copy basic_string_view::substr basic_string_view::compare basic_string_view::starts_with (C++20) basic_string_view::ends_with (C++20) basic_string_view::contains (C++23) basic_string_view::find basic_string_view::rfind basic_string_view::find_first_of basic_string_view::find_last_of basic_string_view::find_first_not_of basic_string_view::find_last_not_of

Elementzugriff basic_string_view::at basic_string_view::operator[] basic_string_view::front basic_string_view::back basic_string_view::data Modifizierer basic_string_view::remove_prefix basic_string_view::remove_suffix basic_string_view::swap Konstanten basic_string_view::npos Nicht-Member-Funktionen operator==operator!=operator<operator>operator<=operator>=operator<=> (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20) operator<< operator""sv Hilfsklassen hash<std::string_view>hash<std::wstring_view>hash<std::u8string_view>hash<std::u16string_view>hash<std::u32string_view> (C++20) Leitfäden zur Deduktion (C++20)

 

Definiert in 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 das erste Element der Sequenz an Position Null steht.

Für eine 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.

(seit C++23)

Eine typische Implementierung hält nur zwei Member: einen Zeiger auf konstante CharT und eine Größe.

Mehrere Typedefs für gängige Zeichentypen werden bereitgestellt

Definiert in 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>

Template-Parameter

CharT	-	Zeichentyp
Traits	-	CharTraits Klasse, die die Operationen auf dem Zeichentyp spezifiziert. Wie bei std::basic_string muss Traits::char_type denselben Typ wie CharT benennen, andernfalls ist das Programm ill-formed.

Member-Typen

Verschachtelter Typ	Definition
traits_type	Traits
value_type	CharT
Zeiger	CharT*
const_pointer	const CharT*
Referenz	CharT&
const_reference	const CharT&
const_iterator	implementierungsabhängige Konstante LegacyRandomAccessIterator, und LegacyContiguousIterator (bis C++20) constexpr-Iteratoren und contiguous_iterator (seit C++20) deren 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 vom selben Typ, da String-Views Ansichten in konstanten Zeichensequenzen sind.

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

Member-Funktionen

Konstruktoren und Zuweisung
(Konstruktor)	konstruiert eine basic_string_view (öffentliche Member-Funktion)
operator=	weist eine Ansicht zu (öffentliche Member-Funktion)
Iteratoren
begincbegin	gibt einen Iterator zum Anfang zurück (öffentliche Member-Funktion)
endcend	gibt einen Iterator zum Ende zurück (öffentliche Member-Funktion)
rbegincrbegin	gibt einen Reverse-Iterator zum Anfang zurück (öffentliche Member-Funktion)
rendcrend	gibt einen Reverse-Iterator zum Ende zurück (öffentliche Member-Funktion)
Elementzugriff
operator[]	greift auf das angegebene Zeichen zu (öffentliche Member-Funktion)
at	greift mit Grenzwertprüfung auf das angegebene Zeichen zu (öffentliche Member-Funktion)
front	greift auf das erste Zeichen zu (öffentliche Member-Funktion)
back	greift auf das letzte Zeichen zu (öffentliche Member-Funktion)
data	gibt einen Zeiger auf das erste Zeichen einer Ansicht zurück (öffentliche Member-Funktion)
Kapazität
sizelength	gibt die Anzahl der Zeichen zurück (öffentliche Member-Funktion)
max_size	gibt die maximale Anzahl von Zeichen zurück (öffentliche Member-Funktion)
empty	prüft, ob die Ansicht leer ist (öffentliche Member-Funktion)
Modifizierer
remove_prefix	verkleinert die Ansicht, indem ihr Anfang nach vorne verschoben wird (öffentliche Member-Funktion)
remove_suffix	verkleinert die Ansicht, indem ihr Ende nach hinten verschoben wird (öffentliche Member-Funktion)
swap	tauscht die Inhalte (öffentliche Member-Funktion)
Operationen
copy	kopiert Zeichen (öffentliche Member-Funktion)
substr	gibt eine Teilzeichenkette zurück (öffentliche Member-Funktion)
compare	vergleicht zwei Ansichten (öffentliche Member-Funktion)
starts_with (C++20)	prüft, ob die Zeichenansicht mit dem gegebenen Präfix beginnt (öffentliche Member-Funktion)
ends_with (C++20)	prüft, ob die Zeichenansicht mit dem gegebenen Suffix endet (öffentliche Member-Funktion)
contains (C++23)	prüft, ob die Zeichenansicht die gegebene Teilzeichenkette oder das gegebene Zeichen enthält (öffentliche Member-Funktion)
find	sucht Zeichen in der Ansicht (öffentliche Member-Funktion)
rfind	sucht das letzte Vorkommen einer Teilzeichenkette (öffentliche Member-Funktion)
find_first_of	findet das erste Vorkommen von Zeichen (öffentliche Member-Funktion)
find_last_of	findet das letzte Vorkommen von Zeichen (öffentliche Member-Funktion)
find_first_not_of	findet das erste Fehlen von Zeichen (öffentliche Member-Funktion)
find_last_not_of	findet das letzte Fehlen von Zeichen (öffentliche Member-Funktion)
Konstanten
npos [static]	spezieller Wert. 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 Zeichenansichten lexikographisch (Funktionsschablone)
Ein-/Ausgabe
operator<< (C++17)	führt die Stromausgabe auf Zeichenansichten durch (Funktionsschablone)

Literale

Definiert im Inline-Namespace std::literals::string_view_literals
operator""sv (C++17)	erzeugt eine Zeichenansicht eines Zeichenkettenliteral (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 (Klassentemplate-Spezialisierung)

Hilfsschablonen

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 lässt basic_string_view borrowed_range erfüllen.

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 lässt basic_string_view view erfüllen.

Deduction Guides

(seit C++20)

Anmerkungen

Es liegt in der Verantwortung des Programmierers sicherzustellen, dass std::string_view nicht länger lebt als das darauf verweisende Zeichenarray

std::string_view good{"a string literal"};
    // "Good" case: `good` points to a static array.
    // String literals reside in persistent data storage.
 
std::string_view bad{"a temporary string"s};
    // "Bad" case: `bad` holds a dangling pointer since the std::string temporary,
    // created by std::operator""s, will be destroyed at the end of the statement.

Spezialisierungen von std::basic_string_view sind bereits trivial kopierbare Typen in allen existierenden Implementierungen, noch bevor die formale Anforderung in C++23 eingeführt wurde.

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

Beispiel

Führen Sie diesen Code aus

#include <iostream>
#include <string_view>
 
int main()
{
    constexpr std::string_view unicode[]{"▀▄─", "▄▀─", "▀─▄", "▄─▀"};
 
    for (int y{}, p{}; y != 6; ++y, p = ((p + 1) % 4))
    {
        for (int x{}; x != 16; ++x)
            std::cout << unicode[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 den Member-Funktionen von basic_string_view zurückgegeben werden, können 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 (Klassenvorlage)
operator+	verbindet zwei Zeichenketten, eine Zeichenkette und ein char oder eine Zeichenkette und eine string_view (function template)
span (C++20)	eine nicht besitzende Ansicht über eine zusammenhängende Sequenz von Objekten (class template)
initializer_list (C++11)	verweist auf ein temporäres Array, das in der Listeninitialisierung erstellt wurde (Klassenvorlage)