Teilen über

basic_string_view-Klasse

  • Artikel

Die Klassenvorlage basic_string_view<charT> wurde in C++17 hinzugefügt, um als sichere und effiziente Methode für eine Funktion zu dienen, um verschiedene nicht verwandte Zeichenfolgentypen zu akzeptieren, ohne dass die Funktion für diese Typen templatiert werden muss. Die Klasse enthält einen nicht eigenen Zeiger auf eine zusammenhängende Abfolge von Zeichendaten und eine Länge, die die Anzahl der Zeichen in der Sequenz angibt. Es wird keine Annahme davon ausgegangen, ob die Sequenz null-beendet ist.

Die Standardbibliothek definiert mehrere Spezialisierungen basierend auf dem Typ der Elemente:

  • string_view
  • wstring_view
  • u16string_view
  • u32string_view

A basic_string_view beschreibt die zum Lesen von Zeichenfolgendaten erforderliche Mindestschnittstelle. Sie bietet zugang zu den zugrunde liegenden Daten; es erstellt keine Kopien (mit Ausnahme der copy Funktion). Die Daten können null Werte (\0) an einer beliebigen Position enthalten. A basic_string_view hat keine Kontrolle über die Lebensdauer des Objekts. Es liegt in der Verantwortung des Aufrufers, sicherzustellen, dass die zugrunde liegenden Zeichenfolgendaten gültig sind.

Eine Funktion, die einen Parameter vom Typ string_view akzeptiert, kann zum Arbeiten mit einem beliebigen Zeichenfolgentyp erstellt werden, ohne die Funktion in eine Vorlage zu verwandeln oder die Funktion auf eine bestimmte Teilmenge von Zeichenfolgentypen zu beschränken. Die einzige Anforderung ist, dass eine implizite Konvertierung vom Zeichenfolgentyp in string_view. Alle Standardmäßigen Zeichenfolgentypen sind implizit in einen string_view Typ konvertierbar, der denselben Elementtyp enthält. Mit anderen Worten, eine std::string ist in ein string_view , aber nicht in ein wstring_view.

Das folgende Beispiel zeigt eine Funktion f ohne Vorlage, die einen Parameter vom Typ wstring_viewverwendet. Sie kann mit Argumenten vom Typ std::wstring, wchar_t*und winrt::hstring.

// compile with: /std:c++17
// string_view that uses elements of wchar_t
void f(wstring_view);

// pass a std::wstring:
const std::wstring& s { L"Hello" };
f(s);

// pass a C-style null-terminated string (string_view is not null-terminated):
const wchar_t* ns = L"Hello";
f(ns);

// pass a C-style character array of len characters (excluding null terminator):
const wchar_t* cs { L"Hello" };
size_t len { 5 };
f({cs,len});

// pass a WinRT string
winrt::hstring hs { L"Hello" };
f(hs);

Syntax

template <class CharType, class Traits = char_traits<CharType>>
class basic_string_view;

Parameter

CharType
Der Typ der Zeichen, die in der basic_string_view. Die C++-Standardbibliothek stellt die folgenden Typedefs für Spezialisierungen dieser Vorlage bereit.

Traits
Wird standardmäßig auf char_traits<CharType> festgelegt.

Konstruktoren

Konstruktor Beschreibung
basic_string_view Erstellt ein leeres basic_string_view oder sonstiges Element, das auf die Daten eines anderen Zeichenfolgenobjekts oder auf ein Zeichenarray im C-Stil verweist.

TypeDefs

Typname Beschreibung
const_iterator Iterator mit wahlfreiem Zugriff, der Elemente lesen const kann.
const_pointer using const_pointer = const value_type*;
const_reference using const_reference = const value_type&;
const_reverse_iterator using const_reverse_iterator = std::reverse_iterator<const_iterator>;
difference_type using difference_type = ptrdiff_t;
iterator using iterator = const_iterator;
npos static constexpr size_type npos = size_type(-1);
pointer using pointer = value_type*;
reference using reference = value_type&;
reverse_iterator using reverse_iterator = const_reverse_iterator;
size_type using size_type = size_t;
traits_type using traits_type = Traits;
value_type using value_type = CharType;

Memberoperatoren

Operator Beschreibung
operator= Weist einem anderen basic_string_viewObjekt ein basic_string_view oder ein konvertierbares Zeichenfolgenobjekt zu.
operator[] Gibt das Element am angegebenen Index zurück.

Memberfunktionen

Memberfunktion Beschreibung
at Gibt ein const_reference Element an einer angegebenen Position zurück.
back Gibt ein const_reference bis zum letzten Element zurück.
begin Gibt einen const Iterator zurück, der das erste Element adressiert. (basic_string_views sind unveränderlich.)
cbegin Wie in begin.
cend Gibt einen const Iterator zurück, der auf eins über das letzte Element zeigt.
copy Kopiert höchstens eine angegebene Anzahl von Zeichen aus einer indizierten Position in einer Quelle basic_string_view in ein Zielzeichenarray. (Nicht empfohlen. Stattdessen verwenden _Copy_s .)
_Copy_s Sichere CRT-Kopierfunktion.
compare Vergleicht eine basic_string_view mit einem angegebenen, basic_string_view um festzustellen, ob sie gleich sind oder ob eine lexikalisch kleiner als die andere ist.
crbegin Wie in rbegin.
crend Wie in rend.
data Gibt einen unformatierten nicht besitzenden Zeiger auf die Zeichensequenz zurück.
empty Überprüft, ob die basic_string_view Zeichen enthalten.
end Wie in cend.
ends_withC++20 Überprüfen Sie, ob eine Zeichenfolgenansicht mit einem angegebenen Suffix endet.
find Sucht in einer Vorwärtsrichtung nach dem ersten Vorkommen einer Teilzeichenfolge, die einer angegebenen Abfolge von Zeichen entspricht.
find_first_not_of Sucht nach dem ersten Zeichen, das kein Element eines angegebenen basic_string_view oder konvertierbaren Zeichenfolgenobjekts ist.
find_first_of Sucht nach dem ersten Zeichen, das einem Element eines angegebenen basic_string_view oder konvertierbaren Zeichenfolgenobjekts entspricht.
find_last_not_of Sucht nach dem letzten Zeichen, das kein Element eines angegebenen basic_string_view oder konvertierbaren Zeichenfolgenobjekts ist.
find_last_of Sucht nach dem letzten Zeichen, das ein Element eines angegebenen basic_string_view oder konvertierbaren Zeichenfolgenobjekts ist.
front Gibt eins const_reference an das erste Element zurück.
length Gibt die aktuelle Anzahl von Elementen zurück.
max_size Gibt die maximale Anzahl von Zeichen zurück, die ein basic_string_view Zeichen enthalten kann.
rbegin Gibt einen const Iterator zurück, der das erste Element in einem umgekehrten Element adressiert basic_string_view.
remove_prefix Verschiebt den Zeiger um die angegebene Anzahl von Elementen vorwärts.
remove_suffix Reduziert die Größe der Ansicht um die angegebene Anzahl von Elementen, die von hinten beginnen.
rend Gibt einen const Iterator zurück, der auf eins über das letzte Element in einem umgekehrten basic_string_viewElement zeigt.
rfind Sucht in umgekehrter basic_string_view Reihenfolge nach dem ersten Vorkommen einer Teilzeichenfolge, die einer angegebenen Abfolge von Zeichen entspricht.
size Gibt die aktuelle Anzahl von Elementen zurück.
starts_withC++20 Überprüfen Sie, ob eine Zeichenfolgenansicht mit einem bestimmten Präfix beginnt.
substr Gibt eine Teilzeichenfolge einer angegebenen Länge ab einem angegebenen Index zurück.
swap Tauschen Sie den Inhalt von zwei basic_string_view Objekten aus.

Hinweise

Wenn eine Funktion aufgefordert wird, eine Sequenz zu generieren, die länger als max_size Elemente ist, meldet die Funktion einen Längenfehler, indem ein Objekt vom Typ length_errorausgelöst wird.

Anforderungen

std:c++17 oder höher.

Header: <string_view>

Namespace:std

basic_string_view::at

Gibt ein const_reference Zeichen am angegebenen nullbasierten Index zurück.

constexpr const_reference at(size_type offset) const;

Parameter

offset
Der Index des elements, auf das verwiesen werden soll.

Rückgabewert

A const_reference bis zum Zeichen an der position, die durch den Parameterindex angegeben wird.

Hinweise

Das erste Element weist einen Index von Null auf, und die folgenden Elemente werden fortlaufend von den positiven ganzen Zahlen indiziert, sodass eine basic_string_view Länge n ein *n*-th-Element mit der Zahl n - 1indiziert hat. at löst eine Ausnahme für ungültige Indizes aus, anders als operator[].

Im Allgemeinen wird empfohlen, dass at Sequenzen wie std::vector z. B. niemals basic_string_view verwendet werden sollten. Ein ungültiger Index, der an eine Sequenz übergeben wird, ist ein Logikfehler, der während der Entwicklung erkannt und behoben werden soll. Wenn ein Programm nicht sicher ist, dass seine Indizes gültig sind, sollte es sie testen, nicht aufrufen und sich auf Ausnahmen verlassen, um sich gegen die unerlässige at() Programmierung zu verteidigen.

Weitere Informationen finden Sie unter basic_string_view::operator[].

Beispiel

// basic_string_view_at.cpp
// compile with: /EHsc
#include <string_view>
#include <iostream>

int main()
{
    using namespace std;

    const string_view  str1("Hello world");
    string_view::const_reference refStr2 = str1.at(8); // 'r'
}

basic_string_view::back

Gibt ein const_reference bis zum letzten Element zurück.

constexpr const_reference back() const;

Rückgabewert

A const_reference bis zum letzten Element in der basic_string_view.

Hinweise

Löst eine Ausnahme aus, wenn dies basic_string_view leer ist.

Denken Sie daran, dass nach einer basic_string_view Änderung, z. B. durch Aufrufen remove_suffix, das von dieser Funktion zurückgegebene Element nicht mehr das letzte Element in den zugrunde liegenden Daten ist.

Beispiel

Ein string_view mit einem C-Zeichenfolgenliteral erstelltes Zeichenfolgenliteral enthält nicht den endierenden Nullwert. Im folgenden Beispiel back wird also zurückgegeben 'p' und nicht '\0'.

char c[] = "Help"; // char[5]
string_view sv{ c };
cout << sv.size(); // size() == 4
cout << sv.back() << endl; // p

Eingebettete Nullen werden als jedes andere Zeichen behandelt:

string_view e = "embedded\0nulls"sv;
cout << boolalpha << (e.back() == 's'); // true

basic_string_view::basic_string_view

Erstellt ein Objekt vom Typ basic_string_view.

constexpr basic_string_view() noexcept;
constexpr basic_string_view(const basic_string_view&) noexcept = default;
constexpr basic_string_view(const charT* str);
constexpr basic_string_view(const charT* str, size_type len);

Parameter

str
Der Zeiger auf die Zeichenwerte.

len
Die Anzahl der Zeichen, die in die Ansicht eingeschlossen werden sollen.

Hinweise

Die Konstruktoren mit einem charT* Parameter gehen davon aus, dass die Eingabe null-beendet ist, die Beendigung null jedoch nicht in der basic_string_view.

Sie können auch ein basic_string_view Literal erstellen. Siehe operator"" sv.

basic_string_view::begin

Wie in cbegin.

constexpr const_iterator begin() const noexcept;

Rückgabewert

Gibt eine const_iterator Adressierung des ersten Elements zurück.

basic_string_view::cbegin

Gibt ein const_iterator , das das erste Element im Bereich adressieren soll.

constexpr const_iterator cbegin() const noexcept;

Rückgabewert

Ein const-Random-Access-Iterator, der auf das erste Element des Bereichs zeigt oder die Position direkt hinter dem Ende eines leeren Bereichs (für einen leeren Bereich gilt cbegin() == cend()).

basic_string_view::cend

Gibt einen const_iterator Wert zurück, der die Position direkt über das letzte Element in einem Bereich adressieren soll.

constexpr const_iterator cend() const noexcept;

Rückgabewert

Gibt einen const-Random-Access-Iterator zurück, der auf eine Position unmittelbar hinter dem Ende des Bereichs verweist.

Hinweise

Der zurückgegebene cend Wert sollte nicht abgeleitet werden.

basic_string_view::compare

Führt einen Vergleich zwischen Groß- und Kleinschreibung mit einem angegebenen basic_string_view (oder einem konvertierbaren Zeichenfolgentyp) durch, um festzustellen, ob die beiden Objekte gleich sind oder ob eins lexikalisch kleiner als der andere ist. Die <string_view> Operatoren verwenden diese Memberfunktion, um Vergleiche zu erledigen.

constexpr int compare(basic_string_view strv) const noexcept;
constexpr int compare(size_type pos, size_type num, basic_string_view strv) const;
constexpr int compare(size_type pos, size_type num, basic_string_view strv, size_type offset, size_type num2) const;
constexpr int compare(const charT* ptr) const;
constexpr int compare(size_type pos, size_type num, const charT* ptr) const;
constexpr int compare(size_type pos, size_type num, const charT* ptr, size_type num2) const;

Parameter

strv
Das basic_string_view ist zu vergleichen.basic_string_view

pos
Der Index, basic_string_view an dem der Vergleich beginnt.

num
Die maximale Anzahl von Zeichen davon basic_string_view , die verglichen werden sollen.

num2
Die maximale Anzahl von Zeichen, die verglichen strv werden sollen.

offset
Der Index, an strv dem der Vergleich beginnt.

ptr
Die C-Zeichenfolge, die mit dieser basic_string_viewverglichen werden soll.

Rückgabewert

  • Ein negativer Wert, wenn dies basic_string_view kleiner als strv oder ptr
  • Null, wenn die beiden Zeichenfolgen gleich sind
  • Ein positiver Wert, wenn dies basic_string_view größer als strv oder höher ist ptr

Hinweise

Die compare Memberfunktionen führen einen Vergleich zwischen Groß- und Kleinschreibung für alle oder einen Teil jeder Zeichensequenz durch.

Beispiel

// basic_string_view_compare.cpp
// compile with: /EHsc
#include <string_view>
#include <iostream>
#include <string>

using namespace std;

string to_alpha(int result)
{
   if (result < 0) return " less than ";
   else if (result == 0) return " equal to ";
   else return " greater than ";
}

int main()
{
   // The first member function compares
   // two string_views
   string_view sv_A("CAB");
   string_view sv_B("CAB");
   cout << "sv_A is " << sv_A << endl;
   cout << "sv_B is " << sv_B << endl;
   int comp1 = sv_A.compare(sv_B);
   cout << "sv_A is" << to_alpha(comp1) << "sv_B.\n";

   // The second member function compares part of
   // an operand string_view to another string_view
   string_view sv_C("AACAB");
   string_view sv_D("CAB");
   cout << "sv_C is: " << sv_C << endl;
   cout << "sv_D is: " << sv_D << endl;
   int comp2a = sv_C.compare(2, 3, sv_D);
   cout << "The last three characters of sv_C are"
       << to_alpha(comp2a) << "sv_D.\n";

   int comp2b = sv_C.compare(0, 3, sv_D);
   cout << "The first three characters of sv_C are"
       << to_alpha(comp2b) << "sv_D.\n";

   // The third member function compares part of
   // an operand string_view to part of another string_view
   string_view sv_E("AACAB");
   string_view sv_F("DCABD");
   cout << "sv_E: " << sv_E << endl;
   cout << "sv_F is: " << sv_F << endl;
   int comp3a = sv_E.compare(2, 3, sv_F, 1, 3);
   cout << "The three characters from position 2 of sv_E are"
       << to_alpha(comp3a)
       << "the 3 characters of sv_F from position 1.\n";

   // The fourth member function compares
   // an operand string_view to a C string
   string_view sv_G("ABC");
   const char* cs_A = "DEF";
   cout << "sv_G is: " << sv_G << endl;
   cout << "cs_A is: " << cs_A << endl;
   int comp4a = sv_G.compare(cs_A);
   cout << "sv_G is" << to_alpha(comp4a) << "cs_A.\n";

   // The fifth member function compares part of
   // an operand string_view to a C string
   string_view sv_H("AACAB");
   const char* cs_B = "CAB";
   cout << "sv_H is: " << sv_H << endl;
   cout << "cs_B is: " << cs_B << endl;
   int comp5a = sv_H.compare(2, 3, cs_B);
   cout << "The last three characters of sv_H are"
      << to_alpha(comp5a) << "cs_B.\n";

   // The sixth member function compares part of
   // an operand string_view to part of an equal length of
   // a C string
   string_view sv_I("AACAB");
   const char* cs_C = "ACAB";
   cout << "sv_I is: " << sv_I << endl;
   cout << "cs_C: " << cs_C << endl;
   int comp6a = sv_I.compare(1, 3, cs_C, 3);
   cout << "The 3 characters from position 1 of sv_I are"
      << to_alpha(comp6a) << "the first 3 characters of cs_C.\n";
}

sv_A is CAB
sv_B is CAB
sv_A is equal to sv_B.
sv_C is: AACAB
sv_D is: CAB
The last three characters of sv_C are equal to sv_D.
The first three characters of sv_C are less than sv_D.
sv_E: AACAB
sv_F is: DCABD
The three characters from position 2 of sv_E are equal to the 3 characters of sv_F from position 1.
sv_G is: ABC
cs_A is: DEF
sv_G is less than cs_A.
sv_H is: AACAB
cs_B is: CAB
The last three characters of sv_H are equal to cs_B.
sv_I is: AACAB
cs_C: ACAB
The 3 characters from position 1 of sv_I are equal to the first 3 characters of cs_C.

basic_string_view::copy

Kopiert höchstens eine angegebene Anzahl von Zeichen aus einer indizierten Position in einer Quelle basic_string_view in ein Zielzeichenarray. Es wird empfohlen, stattdessen die sichere Funktion basic_string_view::_Copy_s zu verwenden.

size_type copy(charT* ptr, size_type count, size_type offset = 0) const;

Parameter

ptr
Das Zielzeichenarray, in das die Elemente kopiert werden sollen.

count
Die Anzahl der Zeichen, die aus der Quelle basic_string_viewkopiert werden sollen.

offset
Die Anfangsposition in der Quelle basic_string_view , aus der Kopien erstellt werden sollen.

Rückgabewert

Die Anzahl von kopierten Zeichen.

Hinweise

Am Ende der Kopie wird kein Nullzeichen angefügt.

basic_string_view::_Copy_s

Secure CRT copy function to be used instead of copy.

size_type _Copy_s(
    value_type* dest,
    size_type dest_size,
    size_type count,
    size_type _Off = 0) const;

Parameter

dest
Das Zielzeichenarray, in das die Elemente kopiert werden sollen.

dest_size
Die Größe des dest.

count Die Anzahl der Zeichen, die höchstens aus der Quellzeichenfolge kopiert werden sollen.

_Off
Die Anfangsposition in der Quellzeichenfolge, ab der Kopien erstellt werden dürfen.

Rückgabewert

Die Anzahl von kopierten Zeichen.

Hinweise

Am Ende der Kopie wird kein Nullzeichen angefügt.

Weitere Informationen finden Sie unter c-runtime-library/security-features-in-the-crt.

basic_string_view::crbegin

Gibt ein const_reverse_iterator , das das erste Element in einem umgekehrten Element adressiert basic_string_view.

constexpr const_reverse_iterator crbegin() const noexcept;

Rückgabewert

A const_reverse_iterator that addresses the first element in a reversed basic_string_view.

basic_string_view::crend

Wie in rend.

constexpr const_reverse_iterator crend() const noexcept;

Rückgabewert

Gibt einen const_reverse_iterator Wert zurück, der das Ende eines umgekehrten Werts angibt basic_string_view.

basic_string_view::data

Gibt einen unformatierten, nicht besitzenden Zeiger auf die Konst-Zeichensequenz des Objekts zurück, das zum Erstellen des basic_string_viewObjekts verwendet wurde.

constexpr value_type *data() const noexcept;

Rückgabewert

Ein Zeiger-zu-Konst auf das erste Element der Zeichensequenz.

Hinweise

Der Zeiger kann die Zeichen nicht ändern.

Eine Abfolge von basic_string_view Zeichen ist nicht unbedingt null-beendet. Der Rückgabetyp ist data keine gültige C-Zeichenfolge, da kein NULL-Zeichen angefügt wird. Das Nullzeichen \0 hat keine besondere Bedeutung in einem Objekt des Typs basic_string_view und kann ein Teil des basic_string_view Objekts sein, genau wie jedes andere Zeichen.

basic_string_view::empty

Überprüft, ob die basic_string_view Zeichen enthalten sind.

constexpr bool empty() const noexcept;

Rückgabewert

true wenn das basic_string_view Objekt keine Zeichen enthält; false wenn es mindestens ein Zeichen enthält.

Hinweise

Die Memberfunktion entspricht size() == 0.

basic_string_view::end

Gibt einen zufälligen Zugriff zurück const_iterator , der auf eins über das letzte Element verweist.

constexpr const_iterator end() const noexcept;

Rückgabewert

Gibt einen zufälligen Zugriff zurück const_iterator , der auf eins über das letzte Element verweist.

Hinweise

end wird verwendet, um zu testen, ob ein Ende const_iterator seines basic_string_view. Der zurückgegebene end Wert sollte nicht abgeleitet werden.

basic_string_view::ends_with

Überprüfen Sie, ob die Zeichenfolgenansicht mit dem angegebenen Suffix endet.

bool ends_with(const CharType c) const noexcept;
bool ends_with(const CharType* const x) const noexcept;
bool ends_with(const basic_string_view sv) const noexcept;

Parameter

c
Das einzelne Zeichensuffix, nach dem gesucht werden soll.

sv
Eine Zeichenfolgenansicht, die das Zusuffix enthält, nach dem gesucht werden soll.
Sie können ein std::basic_string, das in ein basic_string_view.

x
Null-beendete Zeichenfolge, die das Suffix enthält, nach dem gesucht werden soll.

Rückgabewert

true wenn die Zeichenfolgenansicht mit dem angegebenen Suffix endet; false sonst.

Hinweise

ends_with() ist neu in C++20. Geben Sie die /std:c++20 Compileroption an, um sie zu verwenden.

Überprüfen Sie starts_with , ob eine Zeichenfolgenansicht mit dem angegebenen Präfix beginnt.

Beispiel

// Requires /std:c++20 or /std:c++latest
#include <string>
#include <iostream>

int main()
{
    std::cout << std::boolalpha; // so booleans show as 'true'/'false'  
    std::cout << std::string_view("abcdefg").ends_with('g') << '\n';
    std::cout << std::string_view("abcdefg").ends_with("eFg") << '\n';

    std::basic_string<char> str2 = "efg";
    std::cout << std::string_view("abcdefg").ends_with(str2);

    return 0;
}

true
false
true

basic_string_view::find

Durchsucht eine basic_string_view Vorwärtsrichtung nach dem ersten Vorkommen eines Zeichens oder einer Teilzeichenfolge, die einer angegebenen Abfolge von Zeichen(n) entspricht.

constexpr size_type find(basic_string_view str, size_type offset = 0) const noexcept;
constexpr size_type find(charT chVal, size_type offset = 0) const noexcept;
constexpr size_type find(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find(const charT* ptr, size_type offset = 0) const;

Parameter

str
Die basic_string_view Elementfunktion, nach der gesucht werden soll.

chVal
Der Zeichenwert, nach dem die Memberfunktion suchen soll.

offset
Index, bei dem die Suche beginnen soll.

ptr
Die C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

count
Die Anzahl der Zeichen in ptr, die vom ersten Zeichen vorwärts gezählt werden.

Rückgabewert

Der Index des ersten Zeichens der Teilzeichenfolge, nach der bei Erfolg gesucht wird; andernfalls npos.

basic_string_view::find_first_not_of

Sucht nach dem ersten Zeichen, das kein Element eines angegebenen basic_string_view oder konvertierbaren Zeichenfolgenobjekts ist.

constexpr size_type find_first_not_of(basic_string_view str, size_type offset = 0) const noexcept;
constexpr size_type find_first_not_of(charT chVal, size_type offset = 0) const noexcept;
constexpr size_type find_first_not_of(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find_first_not_of(const charT* ptr, size_type offset = 0) const;

Parameter

str
Die basic_string_view Elementfunktion, nach der gesucht werden soll.

chVal
Der Zeichenwert, nach dem die Memberfunktion suchen soll.

offset
Index, bei dem die Suche beginnen soll.

ptr
Die C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

count
Die Anzahl der Zeichen, die vom ersten Zeichen vorwärts gezählt werden, in der C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

Rückgabewert

Der Index des ersten Zeichens der Teilzeichenfolge, nach der bei Erfolg gesucht wird; andernfalls npos.

basic_string_view::find_first_of

Sucht nach dem ersten Zeichen, das einem Element eines angegebenen basic_string_viewElements entspricht.

constexpr size_type find_first_of(basic_string_view str, size_type offset = 0) const noexcept;
constexpr size_type find_first_of(charT chVal, size_type offset = 0) const noexcept;
constexpr size_type find_first_of(const charT* str, size_type offset, size_type count) const;
constexpr size_type find_first_of(const charT* str, size_type offset = 0) const;

Parameter

chVal
Der Zeichenwert, nach dem die Memberfunktion suchen soll.

offset
Index, bei dem die Suche beginnen soll.

ptr
Die C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

count
Die Anzahl der Zeichen, die vom ersten Zeichen vorwärts gezählt werden, in der C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

str
Die basic_string_view Elementfunktion, nach der gesucht werden soll.

Rückgabewert

Der Index des ersten Zeichens der Teilzeichenfolge, nach der bei Erfolg gesucht wird; andernfalls npos.

basic_string_view::find_last_not_of

Sucht nach dem letzten Zeichen, das kein Element eines angegebenen basic_string_viewElements ist.

constexpr size_type find_last_not_of(basic_string_view str, size_type offset = npos) const noexcept;
constexpr size_type find_last_not_of(charT chVal, size_type offset = npos) const noexcept;
constexpr size_type find_last_not_of(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find_last_not_of(const charT* ptr, size_type offset = npos) const;

Parameter

str
Die basic_string_view Elementfunktion, nach der gesucht werden soll.

chVal
Der Zeichenwert, nach dem die Memberfunktion suchen soll.

offset
Index, zu dem die Suche abgeschlossen werden soll.

ptr
Die C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

count
Die Anzahl der Zeichen, die vom ersten Zeichen vorwärts gezählt werden, in ptr.

Rückgabewert

Der Index des ersten Zeichens der Teilzeichenfolge, nach der bei Erfolg gesucht wird; andernfalls string_view::npos.

basic_string_view::find_last_of

Sucht nach dem letzten Zeichen, das einem Element eines angegebenen basic_string_viewElements entspricht.

constexpr size_type find_last_of(basic_string_view str, size_type offset = npos) const noexcept;
constexpr size_type find_last_of(charT chVal, size_type offset = npos) const noexcept;
constexpr size_type find_last_of(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find_last_of(const charT* ptr, size_type offset = npos) const;

Parameter

str
Die basic_string_view Elementfunktion, nach der gesucht werden soll.

chVal
Der Zeichenwert, nach dem die Memberfunktion suchen soll.

offset
Index, zu dem die Suche abgeschlossen werden soll.

ptr
Die C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

count
Die Anzahl der Zeichen, die vom ersten Zeichen vorwärts gezählt werden, in der C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

Rückgabewert

Falls erfolgreich, der Index des letzten Zeichens der gesuchten Teilzeichenfolge, andernfalls npos.

basic_string_view::front

Gibt eins const_reference an das erste Element zurück.

constexpr const_reference front() const;

Rückgabewert

A const_reference bis zum ersten Element.

Hinweise

Löst eine Ausnahme aus, wenn dies basic_string_view leer ist.

basic_string_view::length

Gibt die aktuelle Anzahl von Elementen zurück.

constexpr size_type length() const noexcept;

Hinweise

Die Memberfunktion ist identisch mit size.

basic_string_view::max_size

Gibt die maximale Anzahl von Zeichen zurück, die eins basic_string_view enthalten kann.

constexpr size_type max_size() const noexcept;

Rückgabewert

Die maximale Anzahl von Zeichen, die ein basic_string_view Zeichen enthalten kann.

Hinweise

Eine Ausnahme des Typs length_error wird ausgelöst, wenn ein Vorgang eine basic_string_view länge größer als max_size()erzeugt.

basic_string_view::operator=

Weist einem anderen basic_string_viewObjekt ein basic_string_view oder ein konvertierbares Zeichenfolgenobjekt zu.

constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;

Beispiel

   string_view s = "Hello";
   string_view s2 = s;

basic_string_view::operator[]

Stellt ein const_reference Zeichen mit einem angegebenen Index bereit.

constexpr const_reference operator[](size_type offset) const;

Parameter

offset
Der Index des elements, auf das verwiesen werden soll.

Rückgabewert

A const_reference bis zum Zeichen an der position, die durch den Parameterindex angegeben wird.

Hinweise

Das erste Element weist einen Index von Null auf, und die folgenden Elemente werden nacheinander durch die positiven ganzen Zahlen indiziert, sodass eine basic_string_view Länge n ein *n*-th-Element mit der Zahl n-1indiziert.

operator[]ist schneller als die Memberfunktionat, um Lesezugriff auf die Elemente einer .basic_string_view

operator[] überprüft nicht, ob der als Argument übergebene Index gültig ist. Ein ungültiger Index, der an operator[] ein nicht definiertes Verhalten übergeben wird.

Der zurückgegebene Verweis kann ungültig werden, wenn die zugrunde liegenden Zeichenfolgendaten durch das besitzende Objekt geändert oder gelöscht werden.

Beim Kompilieren mit _ITERATOR_DEBUG_LEVEL dem Satz 1 oder 2 tritt ein Laufzeitfehler auf, wenn Sie versuchen, auf ein Element außerhalb der Grenzen der .basic_string_view Weitere Informationen finden Sie unter Checked Iterators (Überprüfte Iteratoren).

basic_string_view::rbegin

Gibt einen const Iterator an das erste Element in einem umgekehrten basic_string_viewElement zurück.

constexpr const_reverse_iterator rbegin() const noexcept;

Rückgabewert

Gibt einen Iterator für zufälligen Zugriff auf das erste Element in einem umgekehrten basic_string_viewElement zurück, das angibt, was das letzte Element im entsprechenden unreversierten basic_string_viewist.

Hinweise

rbegin wird mit einem umgekehrten basic_string_view verwendet, genau wie begin bei einem basic_string_view. rbegin kann verwendet werden, um eine Iteration rückwärts zu initialisieren.

basic_string_view::remove_prefix

Verschiebt den Zeiger um die angegebene Anzahl von Elementen vorwärts.

constexpr void remove_prefix(size_type n);

Hinweise

Lässt die zugrunde liegenden Daten unverändert. Verschiebt den basic_string_view Mauszeiger nach n Elementen vorwärts und legt das element für private size Daten auf size - n.

basic_string_view::remove_suffix

Reduziert die Größe der Ansicht um die angegebene Anzahl von Elementen, die von hinten beginnen.

constexpr void remove_suffix(size_type n);

Hinweise

Lässt die zugrunde liegenden Daten und den Mauszeiger unverändert. Legt das Mitglied für private size Daten auf size - n.

basic_string_view::rend

Gibt einen const Iterator zurück, der auf eins über das letzte Element in einem umgekehrten basic_string_viewElement zeigt.

constexpr reverse_iterator rend() const noexcept;

Rückgabewert

Ein umgekehrter const Iterator für den zufälligen Zugriff, der auf eins über das letzte Element in einem umgekehrten basic_string_viewElement zeigt.

Hinweise

rend wird mit einem umgekehrten basic_string_view verwendet, genau wie end bei einem basic_string_view. rend kann verwendet werden, um zu testen, ob ein Umgekehrter Iterator das Ende des Iterators basic_string_viewerreicht hat. Der zurückgegebene rend Wert sollte nicht abgeleitet werden.

basic_string_view::rfind

Sucht in basic_string_view umgekehrter Reihenfolge nach einer Teilzeichenfolge, die einer angegebenen Abfolge von Zeichen entspricht.

constexpr size_type rfind(basic_string_view str, size_type offset = npos) const noexcept;
constexpr size_type rfind(charT chVal, size_type offset = npos) const noexcept;
constexpr size_type rfind(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type rfind(const charT* ptr, size_type offset = npos) const;

Parameter

chVal
Der Zeichenwert, nach dem die Memberfunktion suchen soll.

offset
Index, bei dem die Suche beginnen soll.

ptr
Die C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

count
Die Anzahl der Zeichen, die vom ersten Zeichen vorwärts gezählt werden, in der C-Zeichenfolge, nach der die Memberfunktion durchsucht werden soll.

str
Die basic_string_view Elementfunktion, nach der gesucht werden soll.

Rückgabewert

Der Index des ersten Zeichens der Teilzeichenfolge bei erfolgreicher Ausführung; andernfalls npos.

basic_string_view::size

Gibt die Anzahl von Elementen in der basic_string_view zurück.

constexpr size_type size() const noexcept;

Rückgabewert

Die Länge der basic_string_view.

Hinweise

A kann die Länge ändern, z. basic_string_view B. nach remove_prefix und remove_suffix. Da die zugrunde liegenden Zeichenfolgendaten dadurch nicht geändert werden, ist die Größe einer basic_string_view Zeichenfolge nicht unbedingt die Größe der zugrunde liegenden Daten.

basic_string_view::starts_with

Überprüfen Sie, ob die Zeichenfolgenansicht mit dem angegebenen Präfix beginnt.

bool starts_with(const CharType c) const noexcept;
bool starts_with(const CharType* const x) const noexcept;
bool starts_with(const basic_string_view sv) const noexcept;

Parameter

c
Das Präfix des einzelnen Zeichens, nach dem gesucht werden soll.

sv
Eine Zeichenfolgenansicht mit dem Präfix, nach dem gesucht werden soll.
Sie können eine std::basic_stringZeichenfolgenansicht übergeben, die in eine Zeichenfolgenansicht konvertiert wird.

x
Null-beendete Zeichenfolge mit dem Präfix, nach dem gesucht werden soll.

Rückgabewert

true wenn die Zeichenfolge mit dem angegebenen Präfix beginnt; false sonst.

Hinweise

starts_with() ist neu in C++20. Geben Sie die std:c++20 Compileroption an, um sie zu verwenden.

Überprüfen Sie ends_with , ob eine Zeichenfolge mit einem Suffix endet.

Beispiel

// Requires /std:c++20 or /std:c++latest
#include <string>
#include <iostream>

int main()
{
    std::cout << std::boolalpha; // so booleans show as 'true'/'false'  
    std::cout << std::string_view("abcdefg").starts_with('b') << '\n';
    std::cout << std::string_view("abcdefg").starts_with("aBc") << '\n';

    std::basic_string<char> str2 = "abc";
    std::cout << std::string_view("abcdefg").starts_with(str2);

    return 0;
}

false
false
true

basic_string_view::substr

Gibt eine basic_string_view , die (höchstens) die angegebene Anzahl von Zeichen aus einer angegebenen Position darstellt.

constexpr basic_string_view substr(size_type offset = 0, size_type count = npos) const;

Parameter

offset
Ein Index, der das Element an der Position anfindt, an der die Kopie erstellt wird, mit dem Standardwert 0.

count
Die Anzahl der Zeichen, die in die Teilzeichenfolge eingeschlossen werden sollen, wenn sie vorhanden sind.

Rückgabewert

Ein basic_string_view Objekt, das die angegebene Untermenge von Elementen darstellt.

basic_string_view::swap

Tauscht zwei basic_string_viewZeichen, d. h. die Zeiger auf die zugrunde liegenden Zeichenfolgendaten und die Größenwerte.

constexpr void swap(basic_string_view& sv) noexcept;

Parameter

sv
Die Quelle basic_string_view , deren Zeiger- und Größenwerte mit der des Ziels basic_string_viewausgetauscht werden sollen.

Siehe auch

<string_view>
Threadsicherheit in der C++-Standardbibliothek