Halimbawa 1:
Sa sitwasyong ito, dapat tayong magtrabaho kasama ang mga string at data ng input o output, kaya ang 'iostream' at 'string' na mga file ng header ay ibinigay. Kaya, ang mga header file na ito ay kailangang isama dito. Pagkatapos, hindi na namin kailangang isama ang 'std' na ito sa bawat function nang hiwalay sa aming code dahil isinama na namin ang 'namespace std' sa tulong ng 'paggamit' ng keyword. Dito, ang 'pangunahing ()' na function ay tinatawag na. Pagkatapos, ang variable na 'string' na pinangalanang 'originalString' ay sinisimulan gamit ang ilang string. Pagkatapos, sinisimulan namin ang isa pang variable na 'string' na pinangalanang 'salita' sa C++.
Ngayon, sa ilalim nito, ginagamit namin ang 'cout' at i-print ang orihinal na string. Pagkatapos nito, idineklara namin ang 'int Result' at inilalagay ang function na 'contains()' upang suriin kung ang 'originalString' ay naglalaman ng 'salita' o hindi. Inilalagay namin ang 'kung' sa ibaba nito,. Ipinapasa namin ang 'Resulta' sa 'kung'. Kung ang orihinal na string ay naglalaman ng substring, ire-render nito ang pahayag na idinagdag namin pagkatapos ng 'kung'. Sa kaso kapag ang string ay hindi naglalaman ng substring, ang pahayag na ipinakita pagkatapos ng 'iba' ay ire-render.
Code 1:
#include#include
gamit ang namespace std ;
int pangunahing ( )
{
string originalString = 'Gusto ko ang C++ Programming' ;
string na salita = 'C++' ;
cout << 'Ang string ay =' << originalString << endl << endl ;
int Resulta = originalString. naglalaman ng ( salita ) ;
kung ( Resulta )
{
cout << 'Ang salitang matatagpuan sa string na =' << salita << endl ;
}
iba pa
{
cout << 'Ang salitang hindi matatagpuan sa string' << endl ;
}
bumalik 0 ;
}
Output:
Ipinapakita ng kinalabasan na ito na ang substring na makikita natin sa orihinal na string sa tulong ng contains() function ay matatagpuan sa loob ng orihinal na string at ipinapakita dito.
Halimbawa 2:
Ang 'iostream' at 'string' ay ang mga header file na na-import namin sa code na ito. Kasama rin ang 'std' namespace. Pagkatapos, ang main() ay tinatawag dito. Susunod, sinisimulan namin ang variable na 'string' na tinatawag na 'str_1' sa pamamagitan ng pagdaragdag ng ilang string data. Pagkatapos nito, sinisimulan namin ang variable na 'string' na tinatawag na 'str_2' na may 'Rain'.
Sa ibaba nito, ini-print namin ang orihinal na string gamit ang function na 'cout'. Upang matukoy kung ang 'str_2' ay naroroon o wala sa 'str_1', ipinapahayag namin ang 'int Outcome' at inilalagay ang contains() na paraan dito. Sa ibaba, inilalagay namin ang 'kung' at ipinapasa ang 'Kinalabasan' sa 'kung'. Idinaragdag namin ang 'cout' na pahayag pagkatapos i-render ang 'if' kung ang orihinal na string ay may substring. Kung hindi, ang 'cout' na pahayag na darating pagkatapos ng 'else' ay nai-render.
Code 2:
#include#include
gamit ang namespace std ;
int pangunahing ( )
{
string str_1 = 'Malamig ang panahon sa labas' ;
string str_2 = 'Ulan' ;
cout << 'Ang string ay =' << str_1 << endl << endl ;
int kinalabasan = str_1. naglalaman ng ( str_2 ) ;
kung ( kinalabasan )
{
cout << 'Ang salitang matatagpuan sa string na =' << str_2 << endl ;
}
iba pa
{
cout << 'Ang salitang hindi matatagpuan sa string' << endl ;
}
bumalik 0 ;
}
Output:
Isinasaad nito na ang substring na makikita natin sa orihinal na string sa tulong ng paggamit ng contains() function ay hindi matatagpuan sa loob ng orihinal na string at na-render dito bilang isang resulta.
Halimbawa 3:
Ini-import namin ang 'iostream' at 'string' na mga file ng header sa code na ito. Pagkatapos, sa ibaba nito, ginagamit namin ang 'namespace std'. Pagkatapos, ang main() ay hinihingi dito. Ngayon, sinisimulan namin ang dalawang variable ng 'string' na uri ng data na may mga pangalan na 'myString_1' at 'myString_2', ayon sa pagkakabanggit, at italaga ang orihinal na string kung saan gusto naming hanapin ang substring sa 'myString_1' na variable at ang substring ay itinalaga sa variable na 'myString_2'.
Pagkatapos nito, ipinapakita namin ang orihinal na string sa pamamagitan ng paglalagay ng 'myString_1' sa 'cout' na pahayag at pagkatapos ay paglalagay ng 'if' kung saan ginagamit namin ang 'contains()' na paraan na nagsusuri kung ang ibinigay na string ay naglalaman ng substring. Kung ang substring ay naroroon sa orihinal na string, sa tulong ng 'cout', ginagawa namin ang resulta.
Naglalagay kami ng dalawang 'cout' na pahayag kung saan ang isa ay inilalagay pagkatapos ng 'kung' at ang isa ay idinagdag pagkatapos ng 'ibang' bahagi. Kung ang orihinal na string ay naglalaman ng substring, ang 'cout' pagkatapos ng 'if' ay ire-render. Kung ang substring ay hindi nahanap o ang orihinal na string ay walang substring, ang 'cout' pagkatapos ng 'else' ay ire-render.
Code 3:
#include#include
gamit ang namespace std ;
int pangunahing ( )
{
string myString_1 = 'Hi! Hello World' ;
string myString_2 = 'Kamusta' ;
cout << 'Ang kumpletong string ay' << myString_1 << endl ;
kung ( myString_1. naglalaman ng ( myString_2 ) ) {
cout << 'Nahanap ang String = ' << myString_2 << endl ;
}
iba pa {
cout << 'Ang String ay hindi matatagpuan dito' << endl ;
}
bumalik 0 ;
}
Output:
Ang resultang ito ay nagpapakita na ang substring na hinahanap namin sa loob ng orihinal na string gamit ang contains() na paraan ay matatagpuan sa loob ng orihinal na string at ito ay ipinapakita dito.
Halimbawa 4:
Ang 'iostream' at 'string' na mga file ng header ay ini-import sa code na ito. Ang pangunahing() function ay tinatawag dito pagkatapos naming gamitin ang 'namespace std' sa ilalim. Ang mga initialization ng dalawang variable ng 'string' na uri ng data ay pinangalanang 's_1' at 's_2', ayon sa pagkakabanggit. Ang orihinal na string kung saan nais naming matuklasan ang substring ay nakatalaga na ngayon sa variable na 's_1', at ang substring ay ibinibigay sa variable na 's_2'. Ang orihinal na string ay ipinapakita sa pamamagitan ng pagpasok ng 's_1' sa 'cout' na pahayag.
Susunod, idinagdag namin ang sugnay na 'kung' kung saan ginagamit namin ang contains() na paraan upang matukoy kung ang ibinigay na string ay naglalaman ng substring. Inire-render namin ang output gamit ang 'cout' kung ang substring ay nasa orihinal na string. Dalawang pahayag na 'cout' ang idinaragdag, isa pagkatapos ng 'kung' at isa pa pagkatapos ng 'iba' na bahagi ng code. Ang 'cout' na kasunod ng 'if' ay nai-render kung ang substring ay naroroon sa orihinal na string. Kung hindi, ang 'cout' na kasunod ng 'else' ay ire-render kung ang substring ay hindi matatagpuan sa orihinal na string.
Code 4:
#include#include
gamit ang namespace std ;
int pangunahing ( )
{
string s_1 = 'Hi! Ako si Jack dito'' ;
string s_2 = 'Peter' ;
cout << 'Ang kumpletong string ay =' << s_1 << endl ;
kung ( s_1. naglalaman ng ( s_2 ) ) {
cout << 'Nahanap ang String = ' << s_2 << endl ;
}
iba pa {
cout << 'Hindi nahanap ang String = ' << s_2 << endl ;
}
bumalik 0 ;
}
Output:
Tulad ng nakikita mula sa resultang ito, ang substring na hinanap namin sa loob ng orihinal na teksto gamit ang contains() na paraan ay hindi matatagpuan sa code.
Halimbawa 5:
Dito, gagamitin namin ang 'boost' na library at hanapin kung ang string ay naglalaman ng substring o hindi. Sa pamamaraang ito ng 'boost', ginagamit din namin ang contains() function. Kaya, isinama rin namin ang 'boost/algorithm/string.hpp' header file kasama ang 'iostream' at 'string' na mga header file sa code na ito. Pagkatapos ay inilalagay namin ang 'std' at hinihikayat ang pangunahing() na pamamaraan dito.
Pagkatapos, idineklara namin ang mga variable na 'StringData1' at 'StringData2' ng 'string' na uri ng data at sinisimulan ang string data dito. Ang 'c_result' na variable ng 'bool' na uri ng data ay sinisimulan gamit ang 'boost::algorithm::contains()' at ipinapasa namin ang 'StringData1' at 'StringData2' sa function na ito. Hinahanap din nito ang substring sa orihinal na string at iniimbak ang resulta ng Boolean sa variable na 'c_result'.
Ngayon, inilalagay namin ang “c_result==1” sa “if” sa ibaba. Kung ang Boolean value ng “c_result” ay “1”, ang pahayag pagkatapos ng “if” ay ipapakita. Kung hindi, ito ay lilipat patungo sa 'iba' na bahagi at nilalaktawan ang pahayag na naroroon pagkatapos ng 'kung' at nagre-render ng 'iba' na bahagi ng pahayag.
Code 5:
#include#include
#include
gamit ang namespace std ;
int pangunahing ( ) {
string StringData1 = 'Ang aking unang Programa' ;
string StringData2 = 'una' ;
bool c_result = pagpapalakas :: algorithm :: naglalaman ng ( StringData1 , StringData2 ) ;
kung ( c_resulta == 1 )
{
cout << 'Ang tali ' << ''' << StringData1 << ''' << 'naglalaman ng' << StringData2 << endl ;
}
iba pa
{
cout << 'Ang ibinigay na salita ay wala sa string.' ;
}
bumalik 0 ;
}
Output:
Ang substring ay matatagpuan na ngayon sa orihinal na string na makikita natin sa kinalabasan na ito.
Konklusyon
Ginalugad namin ang contains() na paraan na ibinigay ng C++ na wika nang detalyado. Nabanggit din namin na ang contains() function ay available lang sa “C+++ 23”. Ginalugad namin kung ang contains() function ay tumutulong sa paghahanap ng substring sa orihinal na string o kung nakakatulong ito sa pagsuri kung ang string ay naglalaman ng substring o hindi at nai-render ang resulta nang naaayon.