C ++ - String beginnt mit

Es kommt eine Zeit, in der der Programmierer wissen muss, mit was eine Zeichenfolge beginnt. Dieses Wissen kann verwendet werden, um Elemente in einer Liste von Zeichen auszuwählen oder zu beseitigen. Ein Programmierer möchte also wissen, ob eine Zeichenfolge mit einem bestimmten Zeichen oder mit einer bestimmten Unterstring beginnt. Ein Programmierer kann Code schreiben, mit dem die ersten Zeichen einer Zeichenfolge von 1: Ring überprüft und diese mit einem Präfix-Unterstring verglichen werden. Alle beteiligten Strategien wurden jedoch bereits in der C ++ - String -Bibliothek durchgeführt.

Die C ++ - String -Klasse der String -Bibliothek hat die Mitgliedsfunktion, starts_with (). Dies erledigt die Arbeit für den Programmierer, aber der Programmierer muss wissen, wie die Funktion verwendet wird. Und deshalb wird dieses Tutorial produziert. Es gibt drei Varianten der String start_with () Mitgliedsfunktion. Varianten derselben Funktion werden überlastete Funktionen bezeichnet.

Der grundlegende Ansatz für die Member-Funktion start_with () besteht darin, einen kurzen unabhängigen Unterstring mit dem ersten kurzen Segment der betreffenden Zeichenfolge zu vergleichen. Wenn sie gleich sind, gibt die Funktion wahr zurück. Wenn sie unterschiedlich sind, gibt die Funktion falsch zurück.

Achtung: Die Member -Funktion start_with () ist eine C ++ 20 -Funktion. In diesem Artikel sind wir heute im Jahr 2021, sodass Ihr Compiler die Code -Beispiele möglicherweise nicht erfolgreich kompiliert.

Artikelinhalt

• bool startet_with (Diagramm x) const
• bool startet_with (const chart* x) const
• bool startet_with (Basic_string_view x) const
• Abschluss

bool startet_with (Diagramm x) const

Diese Mitgliedsfunktion überprüft, ob die Zeichenfolge Literal mit einem bestimmten Zeichen beginnt. Denken Sie daran, dass das Saitenliteral von einem von der String -Klasse instanziierten Objekt stammen muss. Das folgende Programm überprüft, ob die Zeichenfolge mit 'W' in Großbuchstaben beginnt:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Basic_string Str = "Wir gehen weiter.";
bool bl = str = str.startet_with ('w');
Cout <Rückkehr 0;

Die Ausgabe sollte 1 für wahr sein.

Matching ist Fallempfindlichkeit. Die Ausgabe des folgenden Programms sollte also falsch sein:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Basic_String str = "Wir gehen weiter.";
bool bl = str = str.startet_with ('w');
Cout <Rückkehr 0;

Die Ausgabe sollte 0 für false sein.

Eine Zeichenfolge kann auch mit einem nicht-alphabetischen Charakter beginnen. Das folgende Programm überprüft, ob die Zeichenfolge mit '[' beginnt:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Basic_StringSTR = "[Hinweis: Hinweis Informationen - - -. - Endnote] ";
bool bl = str = str.beginnt mit('[');
Cout <Rückkehr 0;

Die Ausgabe sollte 1 für wahr sein

bool startet_with (const chart* x) const

Der Programmierer möchte vielleicht wissen, ob eine Reihe von Interessen mit einer bestimmten unabhängigen Unterausrichtung beginnt. In diesem Fall muss er diese Mitgliederfunktion verwenden. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Basic_string Str = "Wir gehen weiter.";
const char* ss = "wir sind";
bool bl = str = str.startet_with (ss);
Cout <Rückkehr 0;

Die Ausgabe sollte 1 für True sein.

Die Übereinstimmung ist Fallempfindlichkeit. Daher sollte die Ausgabe des folgenden Programms, bei dem die unabhängige Unterstring mehr als einen Charakter hat, falsch sein:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Basic_String str = "Wir gehen weiter.";
const char* ss = "wir sind";
bool bl = str = str.startet_with (ss);
Cout <Rückkehr 0;

Die Ausgabe sollte 0 für false sein.

Eine Zeichenfolge kann auch mit nicht alphabetischen Zeichen beginnen. Das folgende Programm überprüft, ob die Zeichenfolge mit einer bestimmten Unterstriche von Zahlen beginnt:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

Basic_StringSTR = "8762HT ist eine Codenummer.";
const char* ss = "8762";
bool bl = str = str.startet_with (ss);
Cout <Rückkehr 0;

Die Ausgabe sollte 1 für wahr sein.

bool startet_with (Basic_string_view x) const

String -Ansicht

Das Argument für die Funktion starts_with kann ein String_view -Objekt sein. Die nächste Frage lautet: "Was ist eine string_view?”. Eine String_View ist ein Bereich aus einer originalen Zeichenfolge, die zur Liste eines neuen String -Objekts wird. Die Zeichen werden nicht aus der ursprünglichen Zeichenfolge kopiert. Sie werden verwiesen. Das heißt, die Elemente der ursprünglichen Zeichenfolge werden nicht kopiert; Sie werden verwiesen. Diese String-View hat jedoch viele der Funktionen, die die String-Klasse hat. Die String_View ist auch eine Klasse, aus der String_View -Objekte erstellt werden. Das folgende Programm zeigt die Ähnlichkeit einer String_View -Klasse und einer String:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

const char* str = "alles, was hochgeht.";
String_view strv (str, 23);
für (int i = 0; i Cout <Cout <Rückkehr 0;

Die Ausgabe ist:

Alles, was hoch geht

Die String_view -Bibliothek musste enthalten sein. Beachten Sie, dass in der Deklaration, String_View und nicht Basic_string_view verwendet wurden. Die ersten 23 Zeichen der ursprünglichen Zeichenfolge wurden zu den Zeichen der String_View. Die Aussage des Programms für die Konstruktion des String_View -Objekts lautet:

String_view strv (str, 23);

Wenn ein Zeichen im Bereich der ursprünglichen Zeichenfolge geändert wird, wird auch die String -Ansicht geändert. Das folgende Programm zeigt dies:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

char str [] = "Alles, was hochgeht, muss herunterkommen.";
String_view strv (str, 23);
Str [1] = 'a'; Str [2] = 'r'; Str [3] = 'L';
für (int i = 0; i Cout <Cout <Rückkehr 0;

Die Ausgabe ist:

Früh ansteht

Die ersten, zweiten und dritten Zeichen der ursprünglichen Zeichenfolge wurden geändert, nachdem das Objekt String_view deklariert worden war. Dies bestätigt, dass die String_View zwar ein Objekt ist, aber auf einen Bereich in der ursprünglichen Zeichenfolge verweist und keine Kopie des Bereichs hat.

Der Text der ursprünglichen Zeichenfolge kann konstant gemacht werden. Verwenden Sie, um dies zu erreichen. Das folgende Programm wird nicht kompiliert und eine Fehlermeldung erstellt, da der Text der ursprünglichen Zeichenfolge konstant gemacht wurde:

#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

const char* str = "alles, was hochgeht.";
String_view strv (str, 23);
Str [1] = 'a'; Str [2] = 'r'; Str [3] = 'L';
für (int i = 0; i Cout <Cout <Rückkehr 0;

String -Argument anzeigen

Die Syntax für die Funktion String_starts () lautet:

bool startet_with (Basic_string_viewx) const

So erstellen Sie ein String_View -Objekt, das oben dargestellt wurde. Übergeben Sie es nach dem Erstellen des Objekts als Argument an die Starts_with () -Staderelementfunktion. Das folgende Programm zeigt dies:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

const char* str = "alles, was hochgeht.";
String_view strv (str, 23);
const char* ss = "alles";
bool bl = str = str.startet_with (ss);
Cout <Rückkehr 0;

Die Ausgabe sollte für 1 wahr sein. Diesmal wurden die Bibliotheken String und String_view enthalten.

Wenn der Programmierer die ursprüngliche Zeichenfolge ändern möchte, muss er ein Array-of-Great als Argument für den Konstruktor String_view anstelle eines konstanten Zeigers auf char verwenden. Das folgende Programm zeigt die Situation, wie sich die ursprüngliche Zeichenfolge ändert:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

char str [] = "Alles, was hochgeht, muss herunterkommen.";
String_view strv (str, 23);
Str [5] = 'a'; Str [6] = 'r'; Str [7] = 'L'; Str [8] = 'r'; Str [9] = 'L';
const char* ss = "jederApple";
bool bl = str = str.startet_with (ss);
Cout <Rückkehr 0;

Die Ausgabe sollte 1 für wahr sein.

Auch wenn das Argument zur Funktion start_with () ein String_view -Objekt ist, wird das Gehäuse weiterhin respektiert. Das folgende Programm zeigt dies:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

char str [] = "Alles, was hochgeht, muss herunterkommen.";
String_view strv (str, 23);
const char* ss = "alles";
bool bl = str = str.startet_with (ss);
Cout <Rückkehr 0;

Die Ausgabe sollte 0 für false sein. Das erste 'e' in der Unterstring befindet sich in Kleinbuchstaben, während sich das erste 'e' in der Interessenfolge in Großbuchstaben befindet.

Wenn das Argument für die Funktion starts_with () eine string_view ist, können Nicht-Alphabet-Zeichen immer noch Teil von Strings sein. Im folgenden Programm werden eine Reihe von aufeinanderfolgenden ganzzahligen Zeichen überprüft, wenn sie die interessierende Zeichenfolge starten, wobei das Argument start_with () ein String_View ist:

#enthalten
#enthalten
#enthalten
Verwenden von Namespace STD;
int main ()

const char* str = "8762HT ist eine Codenummer.";
string_view strv (str);
const char* ss = "8762";
bool bl = str = str.startet_with (ss);
Cout <Rückkehr 0;

Die Ausgabe sollte 1 für True sein.

Abschluss

Die String -Klasse in C ++ hat eine Mitgliedsfunktion namens start_with (). Es prüft, ob eine unterabhängige Zeichenfolge die ersten Zeichen einer Reihe von Interesse bildet (Präfix). Die überladenen Elementfunktionen sind starts_with (Diagramm X), starts_with (const chart* x) und starts_with (string_view x). Jeder gibt einen Bool zurück.

Chrys