Paraan 1: Gamit ang Empty() Member Function
Ang isang diretso at built-in na diskarte sa C++ upang matukoy kung ang isang string ay walang laman ay kinabibilangan ng paggamit ng 'empty()' na function ng miyembro. Ang function na 'empty()' ay bahagi ng karaniwang C++ string class at nagbibigay ng isang maginhawang paraan upang suriin kung ang isang string ay walang mga character.
Narito ang isang simpleng halimbawa na naglalarawan sa paggamit ng empty() function:
#include
#include
gamit namespace std ;
int pangunahing ( ) {
string emptyStr ;
kung ( emptyStr. walang laman ( ) ) {
cout << 'Walang laman ang string.' << endl ;
} iba pa {
cout << 'Walang laman ang string.' << endl ;
}
bumalik 0 ;
}
Sa C++ code snippet na ito, magsisimula kami sa pamamagitan ng pagsasama ng mga kinakailangang header file, gaya ng
Sa aming kaso, ginagamit namin ang function na ito sa string na 'emptyStr'. Kasunod nito, gumagamit kami ng conditional statement upang suriin ang resulta ng Boolean na ibinalik ng function na 'empty()'. Kung ang string ay talagang walang laman, ang aming programa ay naglalabas ng isang mensahe na nagpapahiwatig na ang string ay walang laman. Sa kabilang banda, kung ang string ay naglalaman ng mga character, ang programa ay naglalabas ng isang mensahe na nagsasaad na ang string ay walang laman.
Ang output ng ibinigay na C++ code ay ang mga sumusunod:
Paraan 2: Gamit ang Size() Member Function
Ang isa pang diskarte upang makita kung ang isang C++ string ay walang laman ay nagsasangkot ng paggamit ng 'size()' na function ng miyembro na ibinigay ng 'string' na klase. Hindi tulad ng function na 'empty()' na direktang nagbabalik ng Boolean na nagpapahiwatig ng emptiness, ibinabalik ng 'size()' ang bilang ng mga character na nasa string. Upang suriin kung walang laman, inihahambing namin ang resulta ng 'size()' sa zero dahil ang isang walang laman na string ay may zero na laki.
Narito ang isang halimbawa:
#include#include
gamit namespace std ;
int pangunahing ( ) {
string myEmptyString ;
kung ( myEmptyString. laki ( ) == 0 ) {
cout << 'Walang laman ang ibinigay na string.' << endl ;
} iba pa {
cout << 'Walang laman ang ibinigay na string.' << endl ;
}
bumalik 0 ;
}
Sa halimbawang ito, magsisimula tayo sa pamamagitan ng pagdedeklara ng string variable na pinangalanang 'myEmptyString' nang hindi ito sinisimulan, na iniiwan itong walang laman bilang default. Sa pasulong, ginagamit namin ang function na 'size()' upang matukoy ang laki o bilang ng mga character sa string na 'myEmptyString'. Ang 'if' na pahayag ay sinusuri kung ang laki ay katumbas ng zero na nagpapahiwatig na ang string ay walang laman. Kung matugunan ang kundisyong ito, maglalabas kami ng mensahe sa console na nagsasaad na walang laman ang ibinigay na string. Sa kabaligtaran, kung ang laki ay hindi zero, ang daloy ng kontrol ay lilipat sa 'iba' na bloke at ibang mensahe ang ipapakita na nagpapatunay na ang ibinigay na string ay walang laman.
Paraan 3: Paggamit ng Paghahambing sa isang Empty String Literal
Ang isang karagdagang pamamaraan upang matukoy kung ang isang C++ na string ay walang laman ay nagsasangkot ng direktang paghahambing sa isang walang laman na string na literal. Ang literal na walang laman na string ay kinakatawan ng isang pares ng dobleng panipi na walang mga character sa pagitan ng mga ito tulad ng ''. Malalaman natin kung ang string ay naglalaman ng anumang character sa pamamagitan ng paghahambing ng isang ibinigay na string sa literal na walang laman na string na ito.
Narito ang isang halimbawa na naglalarawan ng diskarteng ito:
#include#include
gamit namespace std ;
int pangunahing ( )
{
string username ;
cout <> username ;
kung ( username == '' )
{
cout << 'Error: Hindi maaaring walang laman ang username.' << endl ;
}
iba pa
{
cout << 'Kamusta, ' << username << '! Maligayang pagdating sa aming platform.' << endl ;
}
bumalik 0 ;
}
Sa kasong ito, naglulunsad kami ng isang application na humihiling sa user na ibigay ang kanilang username. Nagsisimula ang program sa pamamagitan ng pagdedeklara ng string variable na pinangalanang 'username' upang iimbak ang input ng user. Kasunod nito, sinenyasan ang user ng mensaheng 'Ipasok ang iyong username:,' at ang kanilang input ay kinukuha gamit ang stream na 'cin'. Ang programa pagkatapos ay gumagamit ng isang kondisyon na pahayag upang suriin kung ang ipinasok na username ay walang laman na nakakamit sa pamamagitan ng direktang paghahambing nito sa isang walang laman na string literal gamit ang equality operator (==). Kung ang username ay nakitang walang laman, ang programa ay naglalabas ng mensahe ng error na nagsasabing, 'Error: Ang username ay hindi maaaring walang laman'. Gayunpaman, kung walang laman ang username, magpapakita ang program ng personalized na welcome message na isinasama ang inilagay na username na may 'Hello, [username]! Welcome sa aming platform' na pagbati.
Narito ang output kung saan hindi kami nagbigay ng anumang username:
Ang output kapag binigyan ng username ay ang mga sumusunod:
Paraan 4: Paggamit ng Ternary Operator
Ang ternary operator ay maigsi na nagpapahayag ng conditional statement sa isang linya na ginagawang mas compact ang code. Ibinabalik ng ternary operator ang isa sa dalawang value pagkatapos masuri ang kundisyon upang makita kung walang laman ang string. Sa kasong ito, maaari naming gamitin ang function ng miyembro na 'empty()' upang suriin kung may laman at gamitin ang ternary operator upang magtalaga ng kaukulang mensahe.
Narito ang isang mapaglarawang halimbawa:
#include#include
gamit namespace std ;
int pangunahing ( ) {
string sampleString = 'Hello, Mundo!' ;
cout << 'Ang string ay' << ( sampleString. walang laman ( ) ? 'walang laman.' : 'walang laman.' ) << endl ;
bumalik 0 ;
}
Pagkatapos ay idedeklara namin ang isang string variable na pinangalanang 'sampleString' at sinisimulan ito gamit ang 'Hello, World!' nilalaman. Gumagamit kami ng ternary operator sa loob ng 'cout' na pahayag upang matukoy kung walang laman ang string. Sinusuri ng ternary operator ang kundisyon na 'sampleString.empty()', tinitingnan kung walang laman ang string, at ini-print ang katumbas na mensaheng 'Walang laman ang string' kung totoo ang kundisyon, at 'Walang laman ang string' kung ang kundisyon ay mali. Ang programa ay nagtatapos sa pamamagitan ng pagbabalik ng 0 na nagsasaad ng matagumpay na pagtakbo. Ang pagpapatupad ng program na ito ay bumubuo ng sumusunod na output:
Konklusyon
Ang pagtukoy kung walang laman ang isang C++ na string ay mahalaga sa pagmamanipula at pagproseso ng string. Sa artikulong ito, ginalugad namin ang ilang mga pamamaraan, bawat isa ay may mga pakinabang nito. Ang function ng miyembro na 'empty()' ay ang pinakadirekta at karaniwang ginagamit na function na malinaw na nagpapahiwatig ng kawalan ng laman ng isang string. Ang paggamit ng 'size()' ay nag-aalok ng alternatibong diskarte sa pamamagitan ng pagsuri sa haba ng string. Ang paghahambing sa isang literal na walang laman na string ay diretso at madaling maunawaan, habang ang mga operator ng ternary ay nagbibigay ng flexibility sa pagsasama ng tseke sa isang mas kumplikadong lohika. Ang mga partikular na pangangailangan ng programa ay dapat isaalang-alang habang pumipili ng tamang diskarte.