C++ virkne satur apakšvirkni

C Virkne Satur Apaksvirkni



Programmā C++ mums ir virknes datu tips, un mēs varam izmantot dažādas funkcijas, lai veiktu dažādus uzdevumus ar virknēm. Mēs varam pārbaudīt, vai apakšvirkne atrodas sākotnējā virknē. Mēs varam arī teikt, ka “virkne satur apakšvirkni”. Šajā rokasgrāmatā mēs apgūsim paņēmienus, kas mums palīdz atrast “virkne satur apakšvirkni”. Funkcijas “find ()” un “strstr ()” palīdz mums veikt šo uzdevumu C++ programmēšanā.

1. piemērs:

“iostream” un “string” ir galvenes faili, kas ir iekļauti šeit, jo mums ir jāstrādā ar virknēm, kā arī jāievada vai jāizvada dati. Tātad mums šeit ir jāiekļauj šie galvenes faili. Pēc tam mēs iekļaujam “namespace std” ar atslēgvārda “using” palīdzību. Tātad mums nav jāievieto šis “std” ar visām funkcijām atsevišķi mūsu kodā. Pēc tam šeit tiek izsaukta funkcija “main()”.







Tagad mēs deklarējam virkni “str_1” un šim mainīgajam piešķiram dažus virknes datus. Pēc tam mēs inicializējam arī citu datu tipa “string” mainīgo ar nosaukumu “str_2” un šim “str_2” mainīgajam piešķiram “like”. Zemāk mēs izmantojam atslēgvārdu “bool”, lai sniegtu patiesus vai nepatiesus rezultātus. Mēs inicializējam “stringHasStr” ar šo “bool” datu tipu un izmantojam funkciju “find()”. Tiek meklēta “virkne satur apakšvirkni”. “str_1” ir visa virkne, un “str_2” ir apakšvirkne.



Šeit mēs pievienojam arī atslēgvārdu “npos”, kas tiek izmantots, lai parādītu, ka šajā virknē nav nevienas atbilstības. Tas pārbauda, ​​vai virknē ir apakšvirkne, un saglabā rezultātu šajā “stringHasStr” būtības mainīgajā.



Pēc tam mēs virzāmies uz nosacījumu “ja” un nododam šo “stringHasStr” mainīgo šim “if” nosacījumam. Ja rezultāts, kas tiek saglabāts šajā būtības mainīgajā, ir “true”, tiek izmantots paziņojums pēc šī nosacījuma “ja”, kur mēs izmantojam “cout” un parādām šeit atrodamo virkni. Bet, ja šajā būtības mainīgajā tiek saglabāts “viltus” rezultāts, tiek izmantota otra daļa un tiek parādīts, ka virkne šeit nav atrasta.





1. kods:

#include
#include

izmantojot namespace std;
int galvenais ( )
{
virkne str_1 = 'Man patīk C++ programmēšanas valoda' ;
string str_2 = 'patīk' ;
bool stringHasStr = str_1.find ( str_2 ) ! = virkne::npos;
ja ( stringHasStr ) {
cout << 'Mēs šeit atrodam virkni, kas ir' << str_2 << endl;
}
cits {
cout << 'Virka nav atrasta' << endl;
}
atgriezties 0 ;
}



Izvade:

Šī izvade parāda, ka virkne satur apakšvirkni, un parāda to šeit. Mēs to pārbaudām, izmantojot funkciju “atrast ()”.

2. piemērs:

Šeit ir iekļauti trīs galvenes faili, kas ir “iostream”, “string” un “cstring”. Pēc tam pēc 'namespace std' ievietošanas izsauciet 'main()'. Virkne “new_str” tagad ir deklarēta un ir piešķirti daži virknes dati.

Pēc tam mēs inicializējam otru datu tipa “string” mainīgo, ko sauc par “sub_str”, un piešķiram tam vērtību “very”. Pēc tam mēs ievietojam “const char*”. Tādējādi rādītāja vērtību mainīt, lai norādītu uz citu vietu atmiņā, nav iespējams. Mēs deklarējam mainīgo “FindingStr” kā šo “const char*” rādītāju šeit. Mēs to inicializējam ar metodi “strstr()” un nododam abas virknes kopā ar funkciju “c_str()”, kas pārveido virkni rakstzīmju masīvā, kas beidzas ar nulles vērtību. Šī “strstr()” metode palīdz pārbaudīt, vai virknē “new_str” ir apakšvirkne “sub_str”. Pēc tam mums ir “if”, kurā pievienojam “FindingStr”. Ja tā atrod apakšvirkni oriģinālā, tiek izpildīts paziņojums pēc “if”, kur mēs izmantojam “cout”. Ja apakšvirkne netiek atrasta, tā tieši virzās uz daļu “else” un izdrukā rezultātu, kas tiek novietots aiz daļas “else”.

2. kods:

#include
#include
#include

izmantojot namespace std;
int galvenais ( )
{
virkne new_str = 'Ārā līst lietus, un laiks ir ļoti patīkams.' ;
virkne sub_str = 'ļoti' ;
const char * FindingStr = strstr ( new_str.c_str ( ) , sub_str.c_str ( ) ) ;
ja ( FindingStr ) {
cout << 'Mēs atrodam virkni, un virkne ir: << sub_str << endl;
}
cits {
cout << 'Virkne nav atrasta' << endl;
}
atgriezties 0 ;
}

Izvade:

Mēs varam pamanīt, ka dotajā virknē ir ietverta apakšvirkne, jo tā parāda paziņojumu, ko pievienojām aiz “if”, un izdrukā apakšvirkni šeit. Mēs to pārbaudām, izmantojot funkciju “strstr ()”.

3. piemērs:

Šeit mēs inicializējam divus virknes mainīgos: “myNewStr” un “mySubStr”. Pēc tam mēs piešķiram dažus virknes datus un deklarējam divus veselus mainīgos: “posOfStr” un “indexOfStr”.

Zemāk mēs izmantojam cilpu “while()” un šīs “while()” cilpas ietvaros mainīgajam “indexOfStr” piešķiram funkcijas “find()” mainīgo. Šai funkcijai “find()” mēs nododam divus mainīgos, kas ir “mySubStr” un “posOfStr”. Pēc tam ievietojam atslēgvārdu “npos”, kas pārbauda, ​​vai funkcijas “atrast” rezultāts nav vienāds ar “npos”. Pēc tam mēs izmantojam “cout”, kas palielina indeksa vērtību par vienu un saglabā to mainīgajā “posOfStr”.

3. kods:

#include
#include

izmantojot namespace std;
int galvenais ( ) {
string myNewStr = 'Mēs šeit atrodam virkni' ;
virkne mySubStr = 'string' ;
int posOfStr = 0 ;
int indexOfStr;
kamēr ( ( indexOfStr = myNewStr.find ( mySubStr, posOfStr ) ) ! = virkne::npos ) {
cout << 'Apakšvirkne ir' << ''' << mySubStr << ''' << ' Atrasts pie indeksa numura : ' << indexOfStr << endl;
posOfStr = indexOfStr + 1 ;
}
atgriezties 0 ;
}

Izvade:

Šeit tiek parādīts, ka dotajā virknē ir apakšvirkne un šīs virknes indeksa numurs ir “19”, kas tiek parādīts arī šajā iznākumā.

4. piemērs:

Šajā kodā mēs iekļaujam galvenes failu “bits/stdc++.h”. Tagad mums nav jāiekļauj citi galvenes faili, jo tajos ir visas nepieciešamās bibliotēkas. Pēc “main()” izsaukšanas mēs inicializējam datu tipa “string” mainīgos “org_str” un “sub_str”. Pēc tam mēs pievienojam nosacījumu “if”, kurā izmantojam funkciju “strstr ()”. Šī funkcija meklē, lai noskaidrotu, vai dotajā virknē ir vēlamā apakšvirkne. Pēc tam mēs pievienojam paziņojumu “cout”, lai izdrukātu, ka šeit ir atrodama apakšvirkne. Pēc tam mēs ievietojam arī daļu “else”, kas tiek izpildīta tikai tad, ja nav izpildīts nosacījums “if” vai virknē nav atrasta apakšvirkne.

Pēc tam mēs deklarējam mainīgo “sub_str2” un šeit piešķiram virknes datus. Pēc tam tiek ievietots nosacījums “if” un tiek izmantota funkcija “strstr()”. Šī metode meklē, vai piegādātā virkne satur pieprasīto apakšvirkni. Rezultāts tiek izdrukāts šeit, izmantojot komandu “cout”. Mēs arī iekļaujam sadaļu “else”, kas tiek izpildīta tikai tad, ja nav izpildīts nosacījums “ja” vai ja apakšvirkne nevar atrasties virknē.

4. kods:

#include
izmantojot namespace std;
int galvenais ( ) {
virkne org_str = 'C++ programmēšanas valoda' ;
virkne sub_str = 'Programma' ;
ja ( strstr ( org_str.c_str ( ) ,sub_str.c_str ( ) ) )
{
cout << 'Šeit ir apakšvirkne' << ''' << sub_str << ''' << 'ir klāt' << org_str << endl;
}
cits {
cout << 'Apakšvirkne nav iekļauta virknē.' << endl;
}
virkne sub_str2 = 'Java' ;

ja ( strstr ( org_str.c_str ( ) ,sub_str2.c_str ( ) ) )
{
cout << 'Šeit ir apakšvirkne' << ''' << sub_str2 << ''' << 'ir klāt' << org_str << endl;
}
cits {
cout << 'Šajā virknē nav apakšvirknes.' << endl;
}
atgriezties 0 ;
}

Izvade:

Pirmās funkcijas “strstr()” rezultāts parāda, ka virkne satur apakšvirkni, bet otrās funkcijas “strstr()” rezultāts parāda, ka apakšvirknes virknē nav.

Secinājums

Jēdziens “virkne satur apakšvirkni” ir rūpīgi apskatīts šajā rokasgrāmatā. Mēs izpētījām divas metodes, kas palīdz meklēt, vai “virkne satur apakšvirkni”. Šajā rokasgrāmatā mēs izskaidrojām funkcijas “find ()”, kā arī “strstr ()”, kuras C++ nodrošina šī uzdevuma veikšanai. Mēs demonstrējam ar unikāliem piemēriem, kuros mēs uzzinājām, kā izmantot šīs funkcijas, lai pārbaudītu, vai “virkne satur apakšvirkni”.