<string_view>

Ein Wrapper für einen Zeichenbereich

Die std::string_view-Klasse kapselt einen Zeiger auf eine nur lesbare Zeichenfolge und eine Zeichenanzahl eines std::string, einer C-Zeichenkette oder eines nicht-nullterminierten Feldes von Zeichen. Der Warpper ist nur so lange gültig, wie die referenzierte Zeichenfolge existiert. Sie bietet vorrangig Methoden zum Suchen und Vergleichen.

Suchen

Suchmethoden suchen ab sv[pos] in den folgenden maximal n Zeichen einen Teilstring, eine C-Zeichenkette oder ein Zeichen

von vorn	von hinten
`find(str, pos=0)`	`rfind(str, pos=npos)`
`find(ptr, pos, n)`	`rfind(ptr, pos, n)`
`find(ptr, pos=0)`	`rfind(ptr, pos=npos)`
`find(c, pos=0)`	`rfind(c, pos=npos)`

die erste Übereinstimmung	die letzte Übereinstimmung
`find_first_of(str, pos=0)`	`find_last_of(str, pos=npos)`
`find_first_of(ptr, pos, n)`	`find_last_of(ptr, pos, n)`
`find_first_of(ptr, pos=0)`	`find_last_of(ptr, pos=npos)`
`find_first_of(c, pos=0)`	`find_last_of(c, pos=npos)`

die erste Nichtübereinstimmung	die letzte Nichtübereinstimmung
`find_first_not_of(str, pos=0)`	`find_last_not_of(str, pos=npos)`
`find_first_not_of(ptr, pos, n)`	`find_last_not_of(ptr, pos, n)`
`find_first_not_of(ptr, pos=0)`	`find_last_not_of(ptr, pos=npos)`
`find_first_not_of(c, pos=0)`	`find_last_not_of(c, pos=npos)`

Sie liefern den Anfangsindex der gefundenen Kette bzw. des Zeichens, auf das die geforderte Bedingung zutrifft. Bei fehlgeschlagener Suche wird die Konstante std::string_view::npos geliefert.

Ob eine Teilzeichenkette enthalten ist, erkannt man ab C++23 einfacher mit sv.contains(str).

Vergleichen

Vergleiche mit den Operatoren == != < ⇐ >= > sind auch mit C-Zeichenketten möglich.

std::string_view sv = "Asterix";
char*           ptr = "Obelix";
 
if (name == sv || name == ptr)
{
  std::cout << "Die spinnen, die Roemer!\n";
}

Die compare()-Methoden vergleichen in sv bzw. ab sv[pos] maximal n Zeichen mit

`compare(sv2, pos2=0, n2)`	`str[pos2]` bis max. `sv2[pos2+n2]`
`compare(pos, n, sv2, pos2=0, n2=npos)`
`compare(ptr, n2)`	der C-Zeichenkette
`compare(pos, n, ptr, n2=npos)`

Sie liefern

einen negativen Wert, wenn sv lexikographisch vor dem Argument kommt,
einen positiven Wert, wenn sv danach kommt oder
0 bei Übereinstimmung.

Zeichenzugriff

Der Zugriff auf einzelne Zeichen erfolgt mit sv[pos] ungeprüft bzw. sv.at(pos) geprüft. Wenn pos hinter dem Ende liegt, wirft at() eine out_of_range-Ausnahme. Die std::string_view-Objekte können als konstante sequentielle Zeichen-Container aufgefasst und mit lesenden Algorithmen bearbeitet werden. Iteratoren auf den Anfang und hinter das Ende der Zeichenfolge liefern die Methoden

`begin()`	`end()`	vorwärts laufend
`rbegin()`	`rend()`	rückwärts laufend

Größe

Größe und Kapazität sind erfragbar und änderbar.

`empty()`	liefert `true` bei leerer Zeichenkette
`length()`	Anzahl Zeichen
`size()`	dto.
`max_size()`	größtmögliche Zeichenzahl

Einkürzen

Der Zeichenbereich lässt sich an beiden Enden einkürzen, jedoch nicht erweitern:

`remove_prefix(n)`	`n` Zeichen vorn entfernen
`remove_suffix(n)`	`n` Zeichen hinten entfernen

Literale

Zeichenkettenliterale lassen sich durch Anhängen von sv als std::string_view kennzeichnen.

string_view.cpp

#include <iostream>
#include <string>
#include <string_view>
 
void f(std::string_view sv)
{
  for (auto c : sv) std::cout << c;
}
 
auto trim(std::string_view sv, std::string_view delimiters = " \t\r\n")
{
  sv.remove_prefix(std::min(sv.find_first_not_of(delimiters), sv.size()));
  auto pos = sv.find_last_not_of(delimiters); 
  if (pos != sv.npos) sv.remove_suffix(sv.size() - (pos + 1));
  return sv;
}
 
int main()
{
  using namespace std::literals;
 
  const char arr[] = "Hello";
  auto s = "World!\n"s;
  auto sv = "This is a string_view: "sv;
 
  f(sv);
  f(arr);
  f({", ignored", 2});
  f(s);
  std::cout << trim("  This character sequence will be trimmed.   ") << "\n";
}