namespace cpp

C++ lernen, kennen, anwenden

Benutzer-Werkzeuge

Webseiten-Werkzeuge


kennen:include:string_view

<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.

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";
}
kennen/include/string_view.txt · Zuletzt geändert: 2016-12-10 16:56 (Externe Bearbeitung)