1. piemērs:
Šajā situācijā mums ir jāstrādā ar virknēm un ievades vai izvades datiem, tāpēc tiek nodrošināti galvenes faili “iostream” un “string”. Tādējādi šie galvenes faili ir jāiekļauj šeit. Pēc tam mums vairs nav jāiekļauj šis “std” ar katru funkciju atsevišķi mūsu kodā, jo mēs jau iekļāvām “namespace std” ar atslēgvārda “using” palīdzību. Šeit tiek izsaukta funkcija “main ()”. Pēc tam mainīgais “virkne” ar nosaukumu “originalString” tiek inicializēts ar kādu virkni. Pēc tam mēs inicializējam citu “string” mainīgo ar nosaukumu “word” ar C++.
Tagad zem tā mēs izmantojam “cout” un izdrukājam šo oriģinālo virkni. Pēc tam mēs deklarējam “int Result” un ievietojam funkciju “contains()”, lai pārbaudītu, vai “originalString” satur vārdu “word” vai ne. Zem tā ievietojam “ja”. Mēs nododam “Rezultātu” uz “ja”. Ja sākotnējā virkne satur apakšvirkni, tā atveido paziņojumu, ko pievienojām aiz “if”. Gadījumā, ja virknē nav apakšvirknes, tiek atveidots priekšraksts, kas tiek parādīts aiz “else”.
1. kods:
#include#include
izmantojot namespace std ;
starpt galvenais ( )
{
virkne originalString = 'Man patīk C++ programmēšana' ;
virknes vārds = 'C++' ;
cout << 'Virkne ir =' << OriginalString << endl << endl ;
starpt Rezultāts = OriginalString. satur ( vārdu ) ;
ja ( Rezultāts )
{
cout << 'Vārdā atrasts vārds, kas ir =' << vārdu << endl ;
}
cits
{
cout << 'Vārds nav atrasts virknē' << endl ;
}
atgriezties 0 ;
}
Izvade:
Šis rezultāts parāda, ka apakšvirkne, ko mēs atrodam sākotnējā virknē ar funkcijas include() palīdzību, ir atrodama sākotnējā virknē un tiek parādīta šeit.
2. piemērs:
“iostream” un “string” ir galvenes faili, ko importējām šajā kodā. Ir iekļauta arī nosaukumvieta “std”. Tad šeit tiek izsaukts main(). Pēc tam mēs inicializējam “string” mainīgo ar nosaukumu “str_1”, pievienojot dažus virknes datus. Tālāk mēs inicializējam “string” mainīgo ar nosaukumu “str_2” ar “Rain”.
Zem tā mēs izdrukājam oriģinālo virkni, izmantojot funkciju “cout”. Lai noteiktu, vai 'str_2' ir vai nav 'str_1', mēs deklarējam 'int Outcome' un ievietojam šeit ietverto() metodi. Zemāk mēs ievietojam “ja” un nododam “Rezultātu” uz “ja”. Mēs pievienojam paziņojumu “cout” pēc “if” atveidošanas, ja sākotnējā virknē ir apakšvirkne. Pretējā gadījumā tiek atveidots paziņojums “cout”, kas nāk aiz “else”.
2. kods:
#include#include
izmantojot namespace std ;
starpt galvenais ( )
{
virkne str_1 = 'Ārā ir vēss laiks' ;
virkne str_2 = 'Lietus' ;
cout << 'Virkne ir =' << str_1 << endl << endl ;
starpt Rezultāts = str_1. satur ( str_2 ) ;
ja ( Rezultāts )
{
cout << 'Vārdā atrasts vārds, kas ir =' << str_2 << endl ;
}
cits
{
cout << 'Vārds nav atrasts virknē' << endl ;
}
atgriezties 0 ;
}
Izvade:
Tas nozīmē, ka apakšvirkne, ko atrodam sākotnējā virknē, izmantojot funkciju include(), netiek atrasta sākotnējā virknē un rezultātā tiek atveidota šeit.
3. piemērs:
Šajā kodā mēs importējam galvenes 'iostream' un 'string' failus. Tad zem šī mēs izmantojam “namespace std”. Tad šeit tiek izsaukts main(). Tagad mēs inicializējam divus datu tipa “string” mainīgos ar attiecīgi nosaukumiem “myString_1” un “myString_2” un piešķiram sākotnējo virkni, no kuras mēs vēlamies atrast apakšvirkni mainīgajam “myString_1”, un tiek piešķirta apakšvirkne. uz mainīgo “myString_2”.
Pēc tam mēs parādām sākotnējo virkni, ievietojot “myString_1” priekšrakstā “cout” un pēc tam ievietojot “if”, kurā mēs izmantojam “contains()” metodi, kas pārbauda, vai dotajā virknē ir apakšvirkne. Ja apakšvirkne atrodas sākotnējā virknē, ar “cout” palīdzību mēs atveidojam rezultātu.
Mēs ievietojam divus “cout” priekšrakstus, kuros viens tiek likts aiz “if”, bet otrs tiek pievienots aiz daļas “else”. Ja sākotnējā virkne satur apakšvirkni, tiks atveidots “cout” aiz “if”. Ja apakšvirkne netiek atrasta vai sākotnējai virknei nav apakšvirknes, tiks atveidots “cout” aiz “else”.
3. kods:
#include#include
izmantojot namespace std ;
starpt galvenais ( )
{
virkne myString_1 = 'Sveika! Sveika pasaule' ;
virkne myString_2 = 'Sveiki' ;
cout << 'Visa virkne ir' << myString_1 << endl ;
ja ( myString_1. satur ( myString_2 ) ) {
cout << 'Virkne atrasta =' << mana virkne_2 << endl ;
}
cits {
cout << 'Šeit nav atrasta virkne' << endl ;
}
atgriezties 0 ;
}
Izvade:
Šis rezultāts parāda, ka apakšvirkne, kuru meklējam sākotnējā virknē, izmantojot metodi include(), atrodas sākotnējā virknē un tiek parādīta šeit.
4. piemērs:
Šajā kodā tiek importēti galvenes faili “iostream” un “string”. Funkcija main () tiek izsaukta šeit pēc tam, kad esam izmantojuši apakšā esošo “namespace std”. Divu datu tipa “string” mainīgo inicializācijas tiek attiecīgi nosauktas “s_1” un “s_2”. Sākotnējā virkne, no kuras mēs vēlamies atklāt apakšvirkni, tagad tiek piešķirta mainīgajam “s_1”, un apakšvirkne tiek piešķirta mainīgajam “s_2”. Pēc tam tiek parādīta sākotnējā virkne, ievietojot “s_1” priekšrakstā “cout”.
Pēc tam mēs pievienojam klauzulu “if”, kur mēs izmantojam include() metodi, lai noteiktu, vai piegādātā virkne satur apakšvirkni. Mēs atveidojam izvadi, izmantojot “cout”, ja apakšvirkne ir iekļauta sākotnējā virknē. Tiek pievienoti divi paziņojumi “cout”, viens aiz “if” un otrs aiz koda daļas “else”. “cout” aiz “if” tiek atveidots, ja apakšvirkne atrodas sākotnējā virknē. Pretējā gadījumā tiek atveidots “cout”, kas seko “else”, ja apakšvirkne nevar atrasties sākotnējā virknē.
4. kods:
#include#include
izmantojot namespace std ;
starpt galvenais ( )
{
virkne s_1 = 'Sveiki! Es esmu Džeks' ;
virkne s_2 = 'Pēteris' ;
cout << 'Visa virkne ir = ' << s_1 << endl ;
ja ( s_1. satur ( s_2 ) ) {
cout << 'Virkne atrasta =' << s_2 << endl ;
}
cits {
cout << 'Virkne nav atrasta =' << s_2 << endl ;
}
atgriezties 0 ;
}
Izvade:
Kā redzams no šī rezultāta, kodā nav atrasta apakšvirkne, kuru meklējām sākotnējā tekstā, izmantojot metodi include().
5. piemērs:
Šeit mēs izmantosim “pastiprināšanas” bibliotēku un noskaidrosim, vai virknē ir apakšvirkne vai nav. Šajā “pastiprināšanas” metodē mēs izmantojam arī funkciju include(). Tātad šajā kodā mēs iekļaujam arī galvenes failu “boost/algoritm/string.hpp”, kā arī galvenes failus “iostream” un “string”. Pēc tam mēs ievietojam “std” un izsaucam galveno () metodi šeit.
Pēc tam mēs deklarējam datu tipa “string” mainīgos, kas ir “StringData1” un “StringData2”, un inicializējam virknes datus šeit. Datu tipa “bool” mainīgais “c_result” tiek inicializēts ar “boost::algorithm::contains()”, un mēs nododam “StringData1” un “StringData2” šai funkcijai. Tas arī atrod apakšvirkni sākotnējā virknē un saglabā Būla rezultātu mainīgajā “c_result”.
Tagad mēs ievietojam “c_result==1” tālāk esošajā laukā “if”. Ja “c_result” Būla vērtība ir “1”, tiek parādīts priekšraksts aiz “if”. Pretējā gadījumā tas virzās uz daļu “cits” un izlaiž paziņojumu, kas atrodas aiz “if”, un atveido daļas “cits” paziņojumu.
5. kods:
#include#include
#include
izmantojot namespace std ;
starpt galvenais ( ) {
virkne StringData1 = 'Mana pirmā programma' ;
virkne StringData2 = 'pirmais' ;
bool c_result = palielināt :: algoritms :: satur ( StringData1 , StringData2 ) ;
ja ( c_rezultāts == 1 )
{
cout << 'Aukla' << ''' << StringData1 << ''' << ' satur ' << StringData2 << endl ;
}
cits
{
cout << 'Dotais vārds nav klāt virknē.' ;
}
atgriezties 0 ;
}
Izvade:
Apakšvirkne tagad ir atrodama sākotnējā virknē, ko mēs varam redzēt šajā iznākumā.
Secinājums
Mēs detalizēti izpētījām C++ valodas nodrošināto Content() metodi. Mēs arī minējām, ka funkcija satur () ir pieejama tikai “C+++ 23”. Mēs izpētījām, vai funkcija include() palīdz atrast apakšvirkni sākotnējā virknē, vai arī tā palīdz pārbaudīt, vai virkne satur apakšvirkni vai nē, un attiecīgi atveidojām rezultātu.