Beispiel 1:
In dieser Situation müssen wir mit Strings und Eingabe- oder Ausgabedaten arbeiten, daher werden die Header-Dateien „iostream“ und „string“ bereitgestellt. Daher müssen diese Header-Dateien hier eingebunden werden. Danach müssen wir diesen „std“ nicht mehr mit jeder Funktion unabhängig in unseren Code einbinden, da wir den „namespace std“ bereits mit Hilfe des Schlüsselworts „using“ eingebunden haben. Hier wird dann die Funktion „main()“ aufgerufen. Anschließend wird die „string“-Variable mit dem Namen „originalString“ mit einer Zeichenfolge initialisiert. Anschließend initialisieren wir mit C++ eine weitere „String“-Variable namens „word“.
Darunter verwenden wir nun das „cout“ und drucken die Originalzeichenfolge. Danach deklarieren wir das „int Result“ und platzieren die Funktion „contains()“, um zu prüfen, ob der „originalString“ das „word“ enthält oder nicht. Darunter platzieren wir „wenn“. Wir übergeben das „Ergebnis“ an „if“. Wenn die ursprüngliche Zeichenfolge die Teilzeichenfolge enthält, wird die Anweisung gerendert, die wir nach „if“ hinzugefügt haben. Falls die Zeichenfolge die Teilzeichenfolge nicht enthält, wird die Anweisung gerendert, die nach „else“ angezeigt wird.
Code 1:
#include#include
Verwenden des Namensraums std ;
int hauptsächlich ( )
{
string originalString = „Ich mag C++-Programmierung“ ;
Zeichenfolgenwort = „C++“ ;
cout << „Die Zeichenfolge ist =“ << originalString << endl << endl ;
int Ergebnis = originalString. enthält ( Wort ) ;
Wenn ( Ergebnis )
{
cout << „Das in der Zeichenfolge gefundene Wort ist =“ << Wort << endl ;
}
anders
{
cout << „Das Wort wurde in der Zeichenfolge nicht gefunden“ << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Dieses Ergebnis zeigt, dass der Teilstring, den wir mit Hilfe der Funktion enthält() im Originalstring finden, innerhalb des Originalstrings gefunden wird und hier angezeigt wird.
Beispiel 2:
„iostream“ und „string“ sind die Header-Dateien, die wir in diesen Code importiert haben. Der Namespace „std“ ist ebenfalls enthalten. Dann wird hier main() aufgerufen. Als nächstes initialisieren wir die „String“-Variable namens „str_1“, indem wir einige String-Daten hinzufügen. Anschließend initialisieren wir die „string“-Variable namens „str_2“ mit „Rain“.
Darunter drucken wir die Originalzeichenfolge mit der Funktion „cout“. Um festzustellen, ob „str_2“ in „str_1“ vorhanden ist oder nicht, deklarieren wir das „int Outcome“ und fügen hier die Methode „contains()“ ein. Unten platzieren wir das „if“ und übergeben das „Outcome“ an „if“. Wir fügen die „cout“-Anweisung nach der Darstellung von „if“ hinzu, wenn die ursprüngliche Zeichenfolge die Teilzeichenfolge enthält. Andernfalls wird die „cout“-Anweisung wiedergegeben, die nach „else“ folgt.
Code 2:
#include#include
Verwenden des Namensraums std ;
int hauptsächlich ( )
{
Zeichenfolge str_1 = „Das Wetter ist kühl draußen“ ;
Zeichenfolge str_2 = 'Regen' ;
cout << „Die Zeichenfolge ist =“ << str_1 << endl << endl ;
int Ergebnis = str_1. enthält ( str_2 ) ;
Wenn ( Ergebnis )
{
cout << „Das in der Zeichenfolge gefundene Wort ist =“ << str_2 << endl ;
}
anders
{
cout << „Das Wort wurde in der Zeichenfolge nicht gefunden“ << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Dies führt dazu, dass die Teilzeichenfolge, die wir mit Hilfe der Funktion „enthält()“ in der Originalzeichenfolge finden, nicht in der Originalzeichenfolge gefunden wird und daher hier gerendert wird.
Beispiel 3:
Wir importieren die Header-Dateien „iostream“ und „string“ in diesen Code. Darunter verwenden wir dann den „Namespace std“. Dann wird hier main() aufgerufen. Nun initialisieren wir die beiden Variablen des Datentyps „string“ mit den Namen „myString_1“ bzw. „myString_2“ und weisen der Variablen „myString_1“ den ursprünglichen String zu, aus dem wir den Teilstring finden möchten, und der Teilstring wird zugewiesen zur Variable „myString_2“.
Danach zeigen wir den ursprünglichen String an, indem wir „myString_1“ in die „cout“-Anweisung einfügen und dann „if“ einfügen, in dem wir die Methode „contains()“ verwenden, die prüft, ob der angegebene String den Teilstring enthält. Wenn der Teilstring im Originalstring vorhanden ist, rendern wir mit Hilfe von „cout“ das Ergebnis.
Wir platzieren zwei „cout“-Anweisungen, wobei eine nach „if“ und die andere nach dem „else“-Teil eingefügt wird. Wenn die ursprüngliche Zeichenfolge die Teilzeichenfolge enthält, wird das „cout“ nach „if“ gerendert. Wenn die Teilzeichenfolge nicht gefunden wird oder die ursprüngliche Zeichenfolge die Teilzeichenfolge nicht enthält, wird das „cout“ nach „else“ gerendert.
Code 3:
#include#include
Verwenden des Namensraums std ;
int hauptsächlich ( )
{
string myString_1 = „Hallo! Hallo Welt“ ;
string myString_2 = 'Hallo' ;
cout << „Die komplette Zeichenfolge ist“ << myString_1 << endl ;
Wenn ( myString_1. enthält ( meinString_2 ) ) {
cout << „Der String gefunden =“ << meinString_2 << endl ;
}
anders {
cout << „Die Zeichenfolge wurde hier nicht gefunden“ << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Dieses Ergebnis zeigt, dass sich die Teilzeichenfolge, die wir mit der Methode „contains()“ innerhalb der Originalzeichenfolge suchen, innerhalb der Originalzeichenfolge befindet und hier angezeigt wird.
Beispiel 4:
Die Header-Dateien „iostream“ und „string“ werden in diesen Code importiert. Die Funktion main() wird dann hier aufgerufen, nachdem wir den darunter liegenden „Namespace std“ verwendet haben. Die Initialisierungen der beiden Variablen des Datentyps „String“ heißen „s_1“ bzw. „s_2“. Der ursprüngliche String, aus dem wir den Teilstring ermitteln möchten, wird nun der Variablen „s_1“ zugewiesen und der Teilstring wird der Variablen „s_2“ übergeben. Die ursprüngliche Zeichenfolge wird dann angezeigt, indem „s_1“ in die „cout“-Anweisung eingefügt wird.
Als Nächstes fügen wir die „if“-Klausel hinzu, in der wir mithilfe der Methode „contains()“ ermitteln, ob die bereitgestellte Zeichenfolge die Teilzeichenfolge enthält. Wir rendern die Ausgabe mit „cout“, wenn der Teilstring im Originalstring vorhanden ist. Es werden zwei „cout“-Anweisungen hinzugefügt, eine nach „if“ und eine nach dem „else“-Teil des Codes. Das „cout“, das auf „if“ folgt, wird gerendert, wenn die Teilzeichenfolge in der Originalzeichenfolge vorhanden ist. Andernfalls wird das „cout“, das auf „else“ folgt, gerendert, wenn die Teilzeichenfolge nicht in der Originalzeichenfolge gefunden werden kann.
Code 4:
#include#include
Verwenden des Namensraums std ;
int hauptsächlich ( )
{
Zeichenfolge s_1 = „Hallo! Ich bin hier Jack“ ;
Zeichenfolge s_2 = 'Peter' ;
cout << „Die komplette Zeichenfolge ist =“ << s_1 << endl ;
Wenn ( s_1. enthält ( s_2 ) ) {
cout << „Der String gefunden =“ << s_2 << endl ;
}
anders {
cout << „Die Zeichenfolge wurde nicht gefunden =“ << s_2 << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Wie aus diesem Ergebnis hervorgeht, wird die Teilzeichenfolge, nach der wir im Originaltext mit der Methode „contains()“ gesucht haben, nicht im Code gefunden.
Beispiel 5:
Hier verwenden wir die „boost“-Bibliothek und finden heraus, ob die Zeichenfolge die Teilzeichenfolge enthält oder nicht. In dieser „Boost“-Methode verwenden wir auch die Funktion enthält(). Daher fügen wir in diesen Code auch die Header-Datei „boost/algorithm/string.hpp“ sowie die Header-Dateien „iostream“ und „string“ ein. Anschließend platzieren wir den „std“ und rufen hier die main()-Methode auf.
Anschließend deklarieren wir die Variablen „StringData1“ und „StringData2“ vom Datentyp „string“ und initialisieren hier die String-Daten. Die Variable „c_result“ vom Datentyp „bool“ wird mit „boost::algorithm::contains()“ initialisiert und wir übergeben die „StringData1“ und „StringData2“ an diese Funktion. Dadurch wird auch die Teilzeichenfolge in der Originalzeichenfolge gefunden und das boolesche Ergebnis in der Variablen „c_result“ gespeichert.
Jetzt platzieren wir „c_result==1“ im „if“ unten. Wenn der boolesche Wert von „c_result“ „1“ ist, wird die Anweisung nach „if“ angezeigt. Andernfalls bewegt es sich zum „else“-Teil und überspringt die Anweisung, die nach „if“ steht, und gibt die Anweisung des „else“-Teils wieder.
Code 5:
#include#include
#include
Verwenden des Namensraums std ;
int hauptsächlich ( ) {
Zeichenfolge StringData1 = „Mein erstes Programm“ ;
string StringData2 = 'Erste' ;
bool c_result = Schub :: Algorithmus :: enthält ( StringData1 , StringData2 ) ;
Wenn ( c_result == 1 )
{
cout << 'Die Saite ' << ''' << StringData1 << ''' << „enthält“ << StringData2 << endl ;
}
anders
{
cout << „Das angegebene Wort ist in der Zeichenfolge nicht vorhanden.“ ;
}
zurückkehren 0 ;
}
Ausgabe:
Der Teilstring befindet sich nun im Originalstring, was wir in diesem Ergebnis sehen können.
Abschluss
Wir haben die von der C++-Sprache bereitgestellte Methode „contains()“ im Detail untersucht. Wir haben auch erwähnt, dass die Funktion enthält() nur in „C+++ 23“ verfügbar ist. Wir haben untersucht, ob die Funktion enthält() beim Auffinden des Teilstrings im Originalstring hilft oder ob sie bei der Überprüfung hilft, ob der String den Teilstring enthält oder nicht, und haben das Ergebnis entsprechend gerendert.