C++ சரம் காலியாக இருந்தால் எப்படி கண்டறிவது

முறை 1: காலி() உறுப்பினர் செயல்பாட்டைப் பயன்படுத்துதல்

ஒரு சரம் காலியாக உள்ளதா என்பதைத் தீர்மானிக்க C++ இல் உள்ள ஒரு நேரடியான மற்றும் உள்ளமைக்கப்பட்ட அணுகுமுறையானது 'காலி()' உறுப்பினர் செயல்பாட்டைப் பயன்படுத்துகிறது. 'empty()' செயல்பாடு நிலையான C++ சரம் வகுப்பின் ஒரு பகுதியாகும், மேலும் ஒரு சரத்தில் எழுத்துகள் இல்லை என்பதைச் சரிபார்க்க வசதியான வழியை வழங்குகிறது.

காலி() செயல்பாட்டின் பயன்பாட்டை விளக்கும் எளிய எடுத்துக்காட்டு இங்கே:

இந்த C++ குறியீடு துணுக்கில், உள்ளீடு மற்றும் வெளியீட்டு செயல்பாடுகளை எளிதாக்குவதற்கும், சரங்களுடன் வேலை செய்வதற்கும் தேவையான மற்றும் போன்ற தலைப்புக் கோப்புகளைச் சேர்ப்பதன் மூலம் தொடங்குகிறோம். “main()” செயல்பாட்டின் உள்ளே, “emptyStr” என்ற ஸ்ட்ரிங் மாறியை அறிவிக்கிறோம். இந்த சரம் ஆரம்பத்தில் எந்த எழுத்தும் இல்லாமல் காலியாக உள்ளது. பின்னர், C++ “ஸ்ட்ரிங்” வகுப்பால் வழங்கப்பட்ட “காலி()” உறுப்பினர் செயல்பாட்டைப் பயன்படுத்துகிறோம். பெயர் குறிப்பிடுவது போல, 'காலி()' செயல்பாடு அது அழைக்கப்படும் சரம் காலியாக உள்ளதா இல்லையா என்பதை சரிபார்க்கிறது.

எங்கள் விஷயத்தில், 'emptyStr' சரத்தில் இந்த செயல்பாட்டை செயல்படுத்துகிறோம். இதைத் தொடர்ந்து, 'காலி()' செயல்பாட்டின் மூலம் வழங்கப்படும் பூலியன் முடிவை மதிப்பீடு செய்ய நிபந்தனை அறிக்கையைப் பயன்படுத்துகிறோம். சரம் உண்மையில் காலியாக இருந்தால், எங்கள் நிரல் ஒரு செய்தியை வெளியிடுகிறது, இது சரம் காலியாக இருப்பதைக் குறிக்கிறது. மறுபுறம், சரத்தில் எழுத்துக்கள் இருந்தால், நிரல் ஒரு செய்தியை வெளியிடுகிறது, இது சரம் காலியாக இல்லை என்று கூறுகிறது.

வழங்கப்பட்ட C++ குறியீட்டின் வெளியீடு பின்வருமாறு:

முறை 2: அளவு() உறுப்பினர் செயல்பாட்டைப் பயன்படுத்துதல்

C++ சரம் காலியாக உள்ளதா என்பதைக் கண்டறியும் மற்றொரு அணுகுமுறை, 'ஸ்ட்ரிங்' வகுப்பால் வழங்கப்பட்ட 'அளவு()' உறுப்பினர் செயல்பாட்டைப் பயன்படுத்துவதாகும். வெறுமையைக் குறிக்கும் பூலியனை நேரடியாக வழங்கும் “empty()” செயல்பாடு போலல்லாமல், “size()” ஆனது சரத்தில் இருக்கும் எழுத்துகளின் எண்ணிக்கையை வழங்குகிறது. வெறுமையை சரிபார்க்க, வெற்று சரம் பூஜ்ஜிய அளவைக் கொண்டிருப்பதால், “அளவு()” முடிவை பூஜ்ஜியத்துடன் ஒப்பிடுகிறோம்.

இங்கே ஒரு உதாரணம்:

இந்த எடுத்துக்காட்டில், 'myEmptyString' என்ற ஸ்ட்ரிங் மாறியை துவக்காமல், அதை முன்னிருப்பாக காலியாக விடாமல் அறிவிப்பதன் மூலம் தொடங்குகிறோம். முன்னோக்கி நகரும், 'myEmptyString' சரத்தில் உள்ள எழுத்துகளின் அளவு அல்லது எண்ணிக்கையைத் தீர்மானிக்க, 'size()' செயல்பாட்டைப் பயன்படுத்துகிறோம். சரம் காலியாக இருப்பதைக் குறிக்கும் அளவு பூஜ்ஜியத்திற்கு சமமாக உள்ளதா என்பதை “if” அறிக்கை மதிப்பிடுகிறது. இந்த நிபந்தனை பூர்த்தி செய்யப்பட்டால், வழங்கப்பட்ட சரம் காலியாக உள்ளது என்று கன்சோலுக்கு ஒரு செய்தியை வெளியிடுவோம். மாறாக, அளவு பூஜ்ஜியமற்றதாக இருந்தால், கட்டுப்பாட்டு ஓட்டம் 'வேறு' தொகுதிக்கு மாறும் மற்றும் வழங்கப்பட்ட சரம் காலியாக இல்லை என்பதை உறுதிப்படுத்தும் வேறு செய்தி காட்டப்படும்.

முறை 3: ஒரு வெற்று சரத்துடன் ஒப்பிடுதல்

C++ சரம் காலியாக உள்ளதா என்பதைத் தீர்மானிக்க கூடுதல் நுட்பம் ஒரு வெற்று சரத்துடன் நேரடி ஒப்பீடு ஆகும். '' போன்ற எழுத்துக்கள் இல்லாத ஒரு ஜோடி இரட்டை மேற்கோள் குறிகளால் வெற்று சரம் குறிக்கப்படுகிறது. கொடுக்கப்பட்ட சரத்தை இந்த வெற்று சரத்துடன் ஒப்பிடுவதன் மூலம் சரத்தில் ஏதேனும் எழுத்து உள்ளதா என்பதை நாம் கண்டறியலாம்.

இந்த அணுகுமுறையை விளக்கும் ஒரு எடுத்துக்காட்டு இங்கே:

இந்த நிலையில், பயனரின் பயனர்பெயரை வழங்குமாறு கேட்கும் பயன்பாட்டை நாங்கள் தொடங்குகிறோம். பயனரின் உள்ளீட்டைச் சேமிக்க “பயனர்பெயர்” என்ற சரம் மாறியை அறிவிப்பதன் மூலம் நிரல் தொடங்குகிறது. பின்னர், 'உங்கள் பயனர்பெயரை உள்ளிடவும்:' என்ற செய்தியுடன் பயனரிடம் கேட்கப்படும், மேலும் அவர்களின் உள்ளீடு 'சின்' ஸ்ட்ரீமைப் பயன்படுத்தி கைப்பற்றப்படும். நிரல் பின்னர் உள்ளிடப்பட்ட பயனர்பெயர் காலியாக உள்ளதா என்பதைச் சரிபார்க்க ஒரு நிபந்தனை அறிக்கையைப் பயன்படுத்துகிறது, இது சமத்துவ ஆபரேட்டரைப் பயன்படுத்தி (==) ஒரு வெற்று சரத்துடன் நேரடியாக ஒப்பிடுவதன் மூலம் அடையப்படுகிறது. பயனர் பெயர் காலியாக இருந்தால், நிரல் ஒரு பிழை செய்தியை வெளியிடுகிறது, அதில் 'பிழை: பயனர் பெயர் காலியாக இருக்க முடியாது'. இருப்பினும், பயனர்பெயர் காலியாக இல்லாவிட்டால், 'ஹலோ, [பயனர்பெயர்]! எங்கள் தளத்திற்கு வரவேற்கிறோம்' வாழ்த்துடன் உள்ளிட்ட பயனர்பெயரை உள்ளடக்கிய தனிப்பயனாக்கப்பட்ட வரவேற்பு செய்தியை நிரல் காட்டுகிறது.

நாங்கள் எந்த பயனர் பெயரையும் வழங்காத வெளியீடு இங்கே:

ஒரு பயனர் பெயர் வழங்கப்படும் போது வெளியீடு பின்வருமாறு:

முறை 4: ஒரு டெர்னரி ஆபரேட்டரைப் பயன்படுத்துதல்

மும்மை ஆபரேட்டர் ஒரு நிபந்தனை அறிக்கையை ஒரு வரியில் சுருக்கமாக வெளிப்படுத்துகிறார், இது குறியீட்டை மிகவும் கச்சிதமாக மாற்றுகிறது. சரம் காலியாக உள்ளதா என்பதைப் பார்க்க, நிபந்தனையை மதிப்பிட்ட பிறகு, டெர்னரி ஆபரேட்டர் இரண்டு மதிப்புகளில் ஒன்றைத் தருகிறார். இந்தச் சந்தர்ப்பத்தில், வெறுமையைச் சரிபார்க்க “காலி()” உறுப்பினர் செயல்பாட்டைப் பயன்படுத்தலாம் மற்றும் தொடர்புடைய செய்தியை வழங்க மும்மை ஆபரேட்டரைப் பயன்படுத்தலாம்.

இங்கே ஒரு விளக்க உதாரணம்:

நாம் 'sampleString' என்ற ஸ்ட்ரிங் மாறியை அறிவித்து, அதை 'Hello, World!' மூலம் துவக்குவோம். உள்ளடக்கம். சரம் காலியாக உள்ளதா என்பதைத் தீர்மானிக்க, “கவுட்” அறிக்கைக்குள் ஒரு மும்முனை ஆபரேட்டரைப் பயன்படுத்துகிறோம். மும்முனை ஆபரேட்டர் “sampleString.empty()” நிபந்தனையை மதிப்பிடுகிறார், சரம் காலியாக உள்ளதா எனச் சரிபார்த்து, நிபந்தனை உண்மையாக இருந்தால் அதற்குரிய 'சரம் காலியாக உள்ளது' செய்தியையும், நிபந்தனையாக இருந்தால் 'சரம் காலியாக இல்லை' என்ற செய்தியையும் அச்சிடுகிறது. பொய். வெற்றிகரமான ஓட்டத்தைக் குறிக்கும் 0 ஐத் திருப்பித் தருவதன் மூலம் நிரல் முடிவடைகிறது. இந்த நிரலின் செயலாக்கம் பின்வரும் வெளியீட்டை உருவாக்குகிறது:

முடிவுரை

C++ சரம் காலியாக உள்ளதா என்பதைக் கண்டறிவது சரம் கையாளுதல் மற்றும் செயலாக்கத்திற்கு அடிப்படையாகும். இந்த கட்டுரையில், பல முறைகளை நாங்கள் ஆராய்ந்தோம், ஒவ்வொன்றும் அதன் நன்மைகள். 'காலி()' உறுப்பினர் செயல்பாடு மிகவும் நேரடியான மற்றும் பொதுவாகப் பயன்படுத்தப்படும் செயல்பாடாகும், இது ஒரு சரத்தின் வெறுமையை தெளிவாகக் குறிக்கிறது. 'அளவு()' ஐப் பயன்படுத்துவது சரத்தின் நீளத்தைச் சரிபார்ப்பதன் மூலம் மாற்று அணுகுமுறையை வழங்குகிறது. ஒரு வெற்று சரத்துடன் ஒப்பிடுவது நேரடியானது மற்றும் உள்ளுணர்வு கொண்டது, அதே சமயம் மும்முனை ஆபரேட்டர்கள் காசோலையை மிகவும் சிக்கலான தர்க்கத்தில் ஒருங்கிணைப்பதில் நெகிழ்வுத்தன்மையை வழங்குகிறார்கள். சரியான அணுகுமுறையைத் தேர்ந்தெடுக்கும்போது திட்டத்தின் குறிப்பிட்ட தேவைகளை கருத்தில் கொள்ள வேண்டும்.