విధానం 1: ఖాళీ() మెంబర్ ఫంక్షన్‌ని ఉపయోగించడం
స్ట్రింగ్ ఖాళీగా ఉందో లేదో తెలుసుకోవడానికి C++లో ఒక సూటిగా మరియు అంతర్నిర్మిత విధానంలో 'ఖాళీ()' మెంబర్ ఫంక్షన్‌ని ఉపయోగించడం ఉంటుంది. “ఖాళీ()” ఫంక్షన్ అనేది ప్రామాణిక C++ స్ట్రింగ్ క్లాస్‌లో భాగం మరియు స్ట్రింగ్‌లో అక్షరాలు లేవని తనిఖీ చేయడానికి అనుకూలమైన మార్గాన్ని అందిస్తుంది.
ఖాళీ() ఫంక్షన్ వినియోగాన్ని వివరించే ఒక సాధారణ ఉదాహరణ ఇక్కడ ఉంది:
#
#
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
స్ట్రింగ్ ఖాళీStr ;
ఉంటే ( ఖాళీStr. ఖాళీ ( ) ) {
కోట్ << 'స్ట్రింగ్ ఖాళీగా ఉంది.' << endl ;
} లేకపోతే {
కోట్ << 'స్ట్రింగ్ ఖాళీగా లేదు.' << endl ;
}
తిరిగి 0 ;
}
ఈ C++ కోడ్ స్నిప్పెట్‌లో, ఇన్‌పుట్ మరియు అవుట్‌పుట్ కార్యకలాపాలను సులభతరం చేయడానికి మరియు స్ట్రింగ్‌లతో పని చేయడానికి
మా విషయంలో, మేము ఈ ఫంక్షన్‌ను “emptyStr” స్ట్రింగ్‌లో అమలు చేస్తాము. దీనిని అనుసరించి, 'ఖాళీ()' ఫంక్షన్ ద్వారా అందించబడిన బూలియన్ ఫలితాన్ని మూల్యాంకనం చేయడానికి మేము షరతులతో కూడిన ప్రకటనను ఉపయోగిస్తాము. స్ట్రింగ్ నిజంగా ఖాళీగా ఉంటే, స్ట్రింగ్ ఖాళీగా ఉందని సూచించే సందేశాన్ని మా ప్రోగ్రామ్ అవుట్‌పుట్ చేస్తుంది. మరోవైపు, స్ట్రింగ్‌లో అక్షరాలు ఉంటే, స్ట్రింగ్ ఖాళీగా లేదని తెలిపే సందేశాన్ని ప్రోగ్రామ్ అవుట్‌పుట్ చేస్తుంది.
అందించిన C++ కోడ్ అవుట్‌పుట్ క్రింది విధంగా ఉంది:
విధానం 2: సైజు() మెంబర్ ఫంక్షన్‌ని ఉపయోగించడం
C++ స్ట్రింగ్ ఖాళీగా ఉందో లేదో తెలుసుకోవడానికి మరొక విధానంలో 'స్ట్రింగ్' క్లాస్ అందించిన 'పరిమాణం()' మెంబర్ ఫంక్షన్‌ని ఉపయోగించడం ఉంటుంది. శూన్యతను సూచించే బూలియన్‌ను నేరుగా అందించే “ఖాళీ()” ఫంక్షన్‌లా కాకుండా, “పరిమాణం()” స్ట్రింగ్‌లో ఉన్న అక్షరాల సంఖ్యను అందిస్తుంది. శూన్యతను తనిఖీ చేయడానికి, ఖాళీ స్ట్రింగ్ సున్నా పరిమాణాన్ని కలిగి ఉన్నందున మేము “పరిమాణం()” ఫలితాన్ని సున్నాతో పోల్చాము.
ఇక్కడ ఒక ఉదాహరణ:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
స్ట్రింగ్ myEmptyString ;
ఉంటే ( myEmptyString. పరిమాణం ( ) == 0 ) {
కోట్ << 'అందించిన స్ట్రింగ్ ఖాళీగా ఉంది.' << endl ;
} లేకపోతే {
కోట్ << 'అందించిన స్ట్రింగ్ ఖాళీగా లేదు.' << endl ;
}
తిరిగి 0 ;
}
ఈ ఉదాహరణలో, మేము 'myEmptyString' అనే స్ట్రింగ్ వేరియబుల్‌ను ప్రారంభించకుండా దానిని డిఫాల్ట్‌గా ఖాళీగా ఉంచడం ద్వారా ప్రారంభిస్తాము. ముందుకు వెళుతున్నప్పుడు, “myEmptyString” స్ట్రింగ్‌లోని పరిమాణాన్ని లేదా అక్షరాల సంఖ్యను గుర్తించడానికి మేము “size()” ఫంక్షన్‌ని అమలు చేస్తాము. 'if' స్టేట్‌మెంట్ పరిమాణం సున్నాకి సమానం కాదా అని అంచనా వేస్తుంది, ఇది స్ట్రింగ్ ఖాళీగా ఉందని సూచిస్తుంది. ఈ షరతు నెరవేరినట్లయితే, మేము అందించిన స్ట్రింగ్ ఖాళీగా ఉందని తెలిపే సందేశాన్ని కన్సోల్‌కు అవుట్‌పుట్ చేస్తాము. దీనికి విరుద్ధంగా, పరిమాణం సున్నా కానట్లయితే, నియంత్రణ ప్రవాహం 'వేరే' బ్లాక్‌కి మారుతుంది మరియు అందించిన స్ట్రింగ్ ఖాళీగా లేదని నిర్ధారించే వేరొక సందేశం ప్రదర్శించబడుతుంది.
విధానం 3: ఖాళీ స్ట్రింగ్ లిటరల్‌తో పోలికను ఉపయోగించడం
C++ స్ట్రింగ్ ఖాళీగా ఉందో లేదో తెలుసుకోవడానికి అదనపు టెక్నిక్‌లో అక్షరార్థమైన ఖాళీ స్ట్రింగ్‌తో నేరుగా పోలిక ఉంటుంది. '' వంటి అక్షరాలు లేని ఒక జత డబుల్ కొటేషన్ గుర్తుల ద్వారా ఖాళీ స్ట్రింగ్ లిటరల్ సూచించబడుతుంది. ఇచ్చిన స్ట్రింగ్‌ని ఈ ఖాళీ స్ట్రింగ్ లిటరల్‌తో పోల్చడం ద్వారా స్ట్రింగ్ ఏదైనా అక్షరాన్ని కలిగి ఉందో లేదో మనం నిర్ధారించుకోవచ్చు.
ఈ విధానాన్ని వివరించే ఉదాహరణ ఇక్కడ ఉంది:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( )
{
స్ట్రింగ్ వినియోగదారు పేరు ;
కోట్ <> వినియోగదారు పేరు ;
ఉంటే ( వినియోగదారు పేరు == '' )
{
కోట్ << 'లోపం: వినియోగదారు పేరు ఖాళీగా ఉండకూడదు.' << endl ;
}
లేకపోతే
{
కోట్ << 'హలో, ' << వినియోగదారు పేరు << '! మా ప్లాట్‌ఫారమ్‌కు స్వాగతం.' << endl ;
}
తిరిగి 0 ;
}
ఈ సందర్భంలో, మేము వినియోగదారుని వారి వినియోగదారు పేరును అందించమని అడిగే అప్లికేషన్‌ను ప్రారంభిస్తాము. వినియోగదారు ఇన్‌పుట్‌ను నిల్వ చేయడానికి “యూజర్‌నేమ్” అనే స్ట్రింగ్ వేరియబుల్‌ను ప్రకటించడం ద్వారా ప్రోగ్రామ్ ప్రారంభమవుతుంది. తదనంతరం, వినియోగదారు 'మీ వినియోగదారు పేరును నమోదు చేయండి:' సందేశంతో ప్రాంప్ట్ చేయబడతారు మరియు వారి ఇన్‌పుట్ “సిన్” స్ట్రీమ్‌ని ఉపయోగించి క్యాప్చర్ చేయబడుతుంది. ప్రోగ్రామ్ ఎంటర్ చేసిన వినియోగదారు పేరు ఖాళీగా ఉందో లేదో తనిఖీ చేయడానికి షరతులతో కూడిన స్టేట్‌మెంట్‌ను ఉపయోగిస్తుంది, ఇది సమానత్వ ఆపరేటర్ (==)ని ఉపయోగించి నేరుగా ఖాళీ స్ట్రింగ్‌తో పోల్చడం ద్వారా సాధించబడుతుంది. వినియోగదారు పేరు ఖాళీగా ఉన్నట్లు గుర్తించినట్లయితే, ప్రోగ్రామ్ దోష సందేశాన్ని అందజేస్తుంది, ఇది 'లోపం: వినియోగదారు పేరు ఖాళీగా ఉండకూడదు'. అయినప్పటికీ, వినియోగదారు పేరు ఖాళీగా లేకుంటే, ప్రోగ్రామ్ వ్యక్తిగతీకరించిన స్వాగత సందేశాన్ని ప్రదర్శిస్తుంది, అది ఎంటర్ చేసిన వినియోగదారు పేరును 'హలో, [యూజర్‌నేమ్]! మా ప్లాట్‌ఫారమ్‌కు స్వాగతం' గ్రీటింగ్‌తో కలుపుతుంది.
మేము ఏ వినియోగదారు పేరును అందించని అవుట్‌పుట్ ఇక్కడ ఉంది:
వినియోగదారు పేరును అందించినప్పుడు అవుట్‌పుట్ క్రింది విధంగా ఉంటుంది:
విధానం 4: టెర్నరీ ఆపరేటర్‌ని ఉపయోగించడం
టెర్నరీ ఆపరేటర్ ఒకే లైన్‌లో షరతులతో కూడిన స్టేట్‌మెంట్‌ను సంక్షిప్తంగా వ్యక్తపరుస్తుంది, ఇది కోడ్‌ను మరింత కాంపాక్ట్‌గా చేస్తుంది. స్ట్రింగ్ ఖాళీగా ఉందో లేదో చూడటానికి కండిషన్‌ను అంచనా వేసిన తర్వాత టెర్నరీ ఆపరేటర్ రెండు విలువలలో ఒకదాన్ని అందిస్తుంది. ఈ సందర్భంలో, మేము 'ఖాళీ()' సభ్యుల ఫంక్షన్‌ను శూన్యత కోసం తనిఖీ చేయవచ్చు మరియు సంబంధిత సందేశాన్ని కేటాయించడానికి టెర్నరీ ఆపరేటర్‌ను ఉపయోగించవచ్చు.
ఇక్కడ ఒక ఉదాహరణ ఉదాహరణ:
##
ఉపయోగించి నేమ్‌స్పేస్ std ;
int ప్రధాన ( ) {
స్ట్రింగ్ నమూనా స్ట్రింగ్ = 'హలో, వరల్డ్!' ;
కోట్ << 'తీగ ఉంది' << ( నమూనా స్ట్రింగ్. ఖాళీ ( ) ? 'ఖాళీ.' : 'ఖాళీ కాదు.' ) << endl ;
తిరిగి 0 ;
}
మేము 'నమూనా స్ట్రింగ్' అనే స్ట్రింగ్ వేరియబుల్‌ని ప్రకటించి, దానిని 'హలో, వరల్డ్!'తో ప్రారంభించాము. విషయము. స్ట్రింగ్ ఖాళీగా ఉందో లేదో తెలుసుకోవడానికి మేము 'కౌట్' స్టేట్‌మెంట్‌లోని టెర్నరీ ఆపరేటర్‌ని ఉపయోగిస్తాము. టెర్నరీ ఆపరేటర్ “sampleString.empty()” పరిస్థితిని మూల్యాంకనం చేసి, స్ట్రింగ్ ఖాళీగా ఉందో లేదో తనిఖీ చేస్తుంది మరియు షరతు నిజమైతే సంబంధిత 'స్ట్రింగ్ ఖాళీగా ఉంది' సందేశాన్ని మరియు షరతు అయితే 'స్ట్రింగ్ ఖాళీగా లేదు' అని ప్రింట్ చేస్తుంది. తప్పుడు. ప్రోగ్రామ్ విజయవంతమైన పరుగును సూచించే 0ని తిరిగి ఇవ్వడం ద్వారా ముగుస్తుంది. ఈ ప్రోగ్రామ్ యొక్క అమలు కింది అవుట్‌పుట్‌ను ఉత్పత్తి చేస్తుంది:
ముగింపు
C++ స్ట్రింగ్ ఖాళీగా ఉందో లేదో గుర్తించడం స్ట్రింగ్ మానిప్యులేషన్ మరియు ప్రాసెసింగ్‌కు ప్రాథమికమైనది. ఈ వ్యాసంలో, మేము అనేక పద్ధతులను అన్వేషించాము, ప్రతి దాని ప్రయోజనాలతో. 'ఖాళీ()' మెంబర్ ఫంక్షన్ అనేది స్ట్రింగ్ యొక్క శూన్యతను స్పష్టంగా సూచించే అత్యంత ప్రత్యక్ష మరియు సాధారణంగా ఉపయోగించే ఫంక్షన్. స్ట్రింగ్ పొడవును తనిఖీ చేయడం ద్వారా “పరిమాణం()”ను ఉపయోగించడం ప్రత్యామ్నాయ విధానాన్ని అందిస్తుంది. అక్షరార్థమైన ఖాళీ స్ట్రింగ్‌తో పోలిక సూటిగా మరియు సహజంగా ఉంటుంది, అయితే టెర్నరీ ఆపరేటర్‌లు చెక్‌ను మరింత సంక్లిష్టమైన లాజిక్‌లోకి చేర్చడంలో సౌలభ్యాన్ని అందిస్తారు. సరైన విధానాన్ని ఎన్నుకునేటప్పుడు ప్రోగ్రామ్ యొక్క నిర్దిష్ట అవసరాలను పరిగణనలోకి తీసుకోవాలి.