எடுத்துக்காட்டு 1:
இந்த குறியீட்டில் 'விருப்ப' மற்றும் 'iostream' தலைப்பு கோப்புகள் இறக்குமதி செய்யப்படுகின்றன. இந்த தலைப்பு கோப்புகளை நாம் இறக்குமதி செய்ய வேண்டும், இதனால் அவற்றில் வரையறுக்கப்பட்ட செயல்பாடுகளை எளிதாக அணுக முடியும். இதற்குப் பிறகு, 'நேம்ஸ்பேஸ் std'ஐச் சேர்ப்போம், எனவே 'std::optional' மற்றும் 'std::cout' போன்ற செயல்பாடுகளுடன் தனித்தனியாக தட்டச்சு செய்ய வேண்டியதில்லை. நாம் இங்கே 'namespace std' ஐப் பயன்படுத்துகிறோம். எனவே, இப்போது, 'விருப்பத்தேர்வு' அல்லது 'கவுட்' என்பதை 'std' என்று தட்டச்சு செய்யாமல் வைக்கிறோம்.
பின்னர், நாங்கள் main() ஐ அழைத்து 'விரும்பினால்' என்று வைத்து அதை 'int' ஆக அமைத்து 'myNum' என்று அறிவிக்கிறோம். இது 'std::optional' மாறியை அறிவிப்பதற்கான தொடரியல் ஆகும். பின்னர், 'மதிப்பு' என்ற பெயரிடப்பட்ட மற்றொரு மாறியை துவக்கி, value_or() செயல்பாட்டைப் பயன்படுத்தி 'myNum' மாறிக்கு மதிப்பை ஒதுக்குவோம். இந்தச் செயல்பாட்டில் நாம் “99” ஐக் கடந்து செல்கிறோம், எனவே மதிப்பு இல்லை என்றால், இந்த “99” ஐ “muNum” மாறிக்கு ஒதுக்குகிறது மற்றும் அதை “மதிப்பு” மாறியில் சேமிக்கிறது. பின்னர், அதன் கீழே 'cout' ஐ வைக்கிறோம், இது மேலே உள்ள மாறிக்கு நாம் ஒதுக்கிய மதிப்பைக் காட்ட உதவுகிறது.
குறியீடு 1:
# <விரும்பினால்> அடங்கும்#
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
முழு எண்ணாக முக்கிய ( ) {
விருப்பமானது < முழு எண்ணாக > myNum ;
முழு எண்ணாக மதிப்பு = myNum. மதிப்பு_அல்லது ( 99 ) ;
கூட் << 'myNum இன் மதிப்பு:' << மதிப்பு << endl ;
திரும்ப 0 ;
}
வெளியீடு:
இங்கே, “99” காட்டப்படுவதை நாம் கவனிக்கலாம், அதாவது மதிப்பு மேலே இல்லை மற்றும் நாம் சேர்த்த மதிப்பு அந்த மாறிக்கு ஒதுக்கப்பட்டுள்ளது.
எடுத்துக்காட்டு 2:
முதலில் தலைப்புக் கோப்புகளைச் சேர்த்து, “namespace std” ஐ வைக்கிறோம். இப்போது, இதன் அடியில், “std::optional” செயல்பாட்டை அறிவிக்கிறோம், அது “divideFunc()”. 'ஈவுத்தொகை' மற்றும் 'வகுப்பான்' இந்த செயல்பாட்டின் இரண்டு அளவுருக்கள். அதற்குக் கீழே “if” ஐப் பயன்படுத்துகிறோம், அங்கு “divisior != 0” என்று ஒரு நிபந்தனையைச் சேர்க்கிறோம். இது திருப்தி அடைந்தால், இதற்குள் 'திரும்ப' சேர்க்கும்போது இந்தப் பிரிவின் பதிலை இது வழங்குகிறது. இல்லையெனில், அது 'nullopt' ஐ வழங்குகிறது, அதாவது பாதுகாப்பான வகை மதிப்பு இல்லை. இப்போது, நாம் முக்கிய () ஐ அழைக்கிறோம். “std::optional” ஐ ஊகிக்க, “divideFunc()” ஐ வைத்து அதில் “27, 3” ஐ சேர்த்து “quotient” மாறிக்கு முடிவை ஒதுக்குவோம்.
இங்கே, 'தானியங்கு' முக்கிய சொல்லைப் பயன்படுத்துகிறோம், எனவே அது தானாகவே அதன் தரவு வகையைச் சரிசெய்கிறது. இதற்குப் பிறகு, 'if' ஐச் சேர்ப்போம், அங்கு 'has-value' ஐப் பயன்படுத்துகிறோம், இது ஒரு வகை-மதிப்பு பெறப்பட்டதா என்பதை தீர்மானிக்கிறது. பின்னர், 'கோட்' மாறியில் சேமிக்கப்பட்ட முடிவை வழங்கும் 'கவுட்' ஐ வைக்கிறோம், மேலும் 'வேறு' பகுதியில் வகுப்பி பூஜ்ஜியம் என்று வழங்கும் ஒரு அறிக்கை உள்ளது.
குறியீடு 2:
## <விரும்பினால்> அடங்கும்
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
விருப்பமானது < முழு எண்ணாக > divideFunc ( முழு எண்ணாக ஈவுத்தொகை , முழு எண்ணாக பிரிப்பான் ) {
என்றால் ( பிரிப்பான் != 0 ) {
திரும்ப ஈவுத்தொகை / பிரிப்பான் ;
}
திரும்ப nullopt ;
}
முழு எண்ணாக முக்கிய ( ) {
ஆட்டோ அளவுகோல் = divideFunc ( 27 , 3 ) ;
என்றால் ( அளவுகோல். உள்ளது_மதிப்பு ( ) ) {
கூட் << 'குறிப்பு:' << அளவுகோல். மதிப்பு ( ) << endl ;
} வேறு {
கூட் << 'வகுப்பான் இங்கே பூஜ்ஜியம்' << endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
வெளியீடு வகுத்தல் பூஜ்ஜியமாக இல்லை என்று பொருள் வகுத்தல் பிறகு விளைவாக வழங்குகிறது. இந்த நிகழ்வில், ஒரு மதிப்பு உள்ளதா இல்லையா என்பதைத் தட்டச்சு-பாதுகாப்பாகத் தீர்மானிக்க “std::optional” பயன்படுத்தப்படுகிறது.
எடுத்துக்காட்டு 3:
இங்கே, 'std:: optional' மாறியை அறிவிக்கிறோம், இது main() க்குள் இருக்கும் 'எண்' ஆகும். பின்னர், 'if' ஐப் பயன்படுத்துகிறோம், அதில் இந்த 'எண்' மாறியுடன் has_value() செயல்பாட்டை வைக்கிறோம். இந்த 'எண்' மாறியில் மதிப்பு இருக்கிறதா இல்லையா என்பதை இது சரிபார்க்கிறது. 'எண்' மாறியில் ஒரு மதிப்பு இருந்தால், அது 'if' க்குப் பிறகு நாம் சேர்த்த அறிக்கையை வழங்குகிறது. இல்லையெனில், 'வேறு' என்பதற்குப் பிறகு நாம் வைத்த அறிக்கையை இது வழங்குகிறது.
இப்போது, 'எண்ணை' '92' உடன் துவக்கி, 'இப்போது' என்பதை மீண்டும் பயன்படுத்துகிறோம், இதில் 'நிபந்தனையாக இருந்தால்' இல் உள்ள 'எண்' மாறியுடன் has_value() செயல்பாடு சேர்க்கப்படும். 'எண்' மாறிக்கு மதிப்பு உள்ளதா இல்லையா என்பதை இது தீர்மானிக்கிறது. 'எண்' மாறிக்கு மதிப்பு இருந்தால் 'if' க்குப் பிறகு நாம் சேர்க்கும் வாக்கியம் வழங்கப்படுகிறது. இல்லையெனில், 'மற்றவை' என்பதற்குப் பிறகு நாம் வைக்கும் அறிக்கை வழங்கப்படுகிறது.
குறியீடு 3:
## <விரும்பினால்> அடங்கும்
முழு எண்ணாக முக்கிய ( ) {
வகுப்பு :: விருப்பமானது < முழு எண்ணாக > எண் ;
என்றால் ( எண். உள்ளது_மதிப்பு ( ) ) {
வகுப்பு :: கூட் << 'எண் உள்ளது:' << எண். மதிப்பு ( ) << வகுப்பு :: endl ;
} வேறு {
வகுப்பு :: கூட் << 'எண் இல்லை.' << வகுப்பு :: endl ;
}
எண் = 92 ;
என்றால் ( எண். உள்ளது_மதிப்பு ( ) ) {
வகுப்பு :: கூட் << 'எண் உள்ளது:' << எண். மதிப்பு ( ) << வகுப்பு :: endl ;
} வேறு {
வகுப்பு :: கூட் << 'எண் இல்லை.' << வகுப்பு :: endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
'std::optional' மாறிக்கு எந்த மதிப்பையும் நாங்கள் ஒதுக்காததால், இது 'else' பகுதியை முதலில் வழங்குகிறது. பின்னர், அடுத்த வரியில் அந்த மதிப்பைக் காட்ட இந்த மாறிக்கு மதிப்பை ஒதுக்குகிறோம்.
எடுத்துக்காட்டு 4:
இப்போது, “n1”, “n2” மற்றும் “n3” ஆகிய மூன்று “std:: optional” மாறிகளை அறிவிக்கிறோம். முறையே “29” மற்றும் “45” ஆகிய “n2” மற்றும் “n3” மாறிகளுக்கு மதிப்புகளை ஒதுக்குகிறோம். “std::optional” வகுப்பின் “n1” மாறி இங்கே காலியாக உள்ளது. இப்போது, '1' மற்றும் '0' ஐ விட 'உண்மை' அல்லது 'தவறு' வடிவத்தில் திரும்புவதற்கு உதவும் 'பூலால்பா' ஐப் பயன்படுத்துகிறோம்.
இதற்குப் பிறகு, இந்த “std::optional” மாறிகளுக்கு இடையே உள்ள தொடர்புடைய ஆபரேட்டர்களைப் பயன்படுத்துவோம், மேலும் ஒவ்வொரு அறிக்கையையும் “cout” க்குள் வைப்போம், எனவே அது நாங்கள் சேர்த்த ஒப்பீட்டின் முடிவையும் வழங்கும். முதலில், அது “n3 > n2”, பின்னர் “n3 < n2”, “n1 < n2”, “n1 == std::nullopt ” என்பதைச் சரிபார்க்கிறது. இங்கே, பாதுகாப்பான வகை மதிப்பு அல்லது பூஜ்யத்தை ஒப்பிடுவதற்கு 'nullopt' பயன்படுத்தப்படுகிறது. பின்னர், “cout” அறிக்கையின் உள்ளே “n2 == 49” மற்றும் “n3 == 88” தனித்தனியாக சரிபார்க்கிறோம்.
குறியீடு 4:
# <விரும்பினால்> அடங்கும்#
முழு எண்ணாக முக்கிய ( )
{
வகுப்பு :: விருப்பமானது < முழு எண்ணாக > n1 ;
வகுப்பு :: விருப்பமானது < முழு எண்ணாக > n2 ( 29 ) ;
வகுப்பு :: விருப்பமானது < முழு எண்ணாக > n3 ( நான்கு ) ;
வகுப்பு :: கூட் << வகுப்பு :: எண்ணெழுத்து ;
வகுப்பு :: கூட் << 'தி n3 > n2' << ( n3 > n2 ) << வகுப்பு :: endl ;
வகுப்பு :: கூட் << 'தி n3 < n2' << ( n3 < n2 ) << வகுப்பு :: endl ;
வகுப்பு :: கூட் << 'தி n1 < n2 ' << ( n1 < n2 ) << வகுப்பு :: endl ;
வகுப்பு :: கூட் << 'தி n1 == பூஜ்யம்' << ( n1 == வகுப்பு :: nullopt ) << வகுப்பு :: endl ;
வகுப்பு :: கூட் << 'தி n2 == 49' << ( n2 == 29 ) << வகுப்பு :: endl ;
வகுப்பு :: கூட் << 'தி n3 == 88' << ( n3 == 88 ) << வகுப்பு :: endl ;
}
வெளியீடு:
நாம் முன்பு குறிப்பிட்ட C++ நிரல், வெளியீட்டில் முடிவை அச்சிடும்போது, “std::optional” வகையின் பல்வேறு மாறி மதிப்புகளை ஒப்பிடுகிறது.
எடுத்துக்காட்டு 5:
இந்தக் குறியீட்டில் சேர்க்கப்பட்டுள்ள தலைப்புக் கோப்புகள் “iostream”, “fstream”, “optional” மற்றும் “string” ஆகும். இந்த குறியீட்டில் நமக்குத் தேவைப்படும் “ஆஃப்ஸ்ட்ரீம்” மற்றும் “இஃப்ஸ்ட்ரீம்” ஆகிய இரண்டு செயல்பாடுகளின் வரையறையும் “fstream” கொண்டுள்ளது. இப்போது, நாங்கள் 'பெயர்வெளி std' ஐச் சேர்த்துள்ளோம், எனவே ஒவ்வொரு செயல்பாட்டிலும் தனித்தனியாக வைக்க மாட்டோம். பின்னர், 'std:optional' ஐப் பயன்படுத்தி, 'ReadFileFunc' என்ற பெயரில் ஒரு செயல்பாட்டை அறிவிக்கிறோம், அதில் 'const string& f_Name' ஐ வாதமாக அனுப்புவோம்.
பின்னர், 'f_name' மாறியில் பெயர் சேர்க்கப்படும் கோப்பைப் படிக்க உதவும் 'ifstream' எங்களிடம் உள்ளது. பின்னர், “if” ஐப் பயன்படுத்துகிறோம், அதில் கோப்பு திறக்கப்படாவிட்டால், “if” அறிக்கைக்குக் கீழே அதைச் சேர்த்ததால், அது “nullopt” என்பதை வழங்குகிறது. பின்னர், கோப்பு திறக்கப்பட்டால், கோப்பில் உள்ளடக்கத்தை எழுதுவதற்கு உதவும் 'fileContent' என்ற மற்றொரு செயல்பாட்டை நாங்கள் உருவாக்குகிறோம். இங்கே, 'திரும்பக் கோப்பு உள்ளடக்கத்தை' மீண்டும் வைக்கிறோம், இது திறந்த பிறகு கோப்பில் சேர்த்த உள்ளடக்கத்தையும் வழங்குகிறது.
இப்போது, நாம் திறக்க விரும்பும் 'Sample.txt' கோப்பு பெயருடன் 'f_Name' மாறியை துவக்கும் 'main()' ஐ இங்கு அழைக்கிறோம். பின்னர், நாங்கள் இங்கே “ReadFileFunc()” ஐ அழைக்கிறோம் மற்றும் இந்த செயல்பாட்டில் “f_Name” மாறியை அனுப்புகிறோம், இது கோப்பைப் படிக்க முயற்சிக்கிறது மற்றும் அதன் உள்ளடக்கத்தை “f_content” மாறியில் சேமிக்கிறது. இதன் கீழ், 'if' இல் உள்ள 'f_content' மாறியுடன் 'has_value()' ஐப் பயன்படுத்துகிறோம். இந்த மாறி ஒரு மதிப்பைக் கொண்டிருந்தால், 'f_content'ஐயும் 'if'க்குக் கீழே உள்ள 'cout' ஐச் சேர்த்தது போலவும் இது ரெண்டர் ஆகும். இல்லையெனில், 'வேறு' க்குப் பிறகு நாம் சேர்த்த பிழையைக் காட்டுகிறது.
குறியீடு 5:
##
# <விரும்பினால்> அடங்கும்
#
பெயர்வெளி std ஐப் பயன்படுத்துகிறது ;
விருப்பமானது < லேசான கயிறு > ReadFileFunc ( நிலையான லேசான கயிறு & f_பெயர் ) {
ifstream myFile ( f_பெயர் ) ;
என்றால் ( ! myFile. திறந்துள்ளது ( ) ) {
திரும்ப nullopt ;
}
சரம் கோப்பு உள்ளடக்கம் ( ( isstreambuf_iterator < கரி > ( myFile ) ) , isstreambuf_iterator < கரி > ( ) ) ;
திரும்ப கோப்பு உள்ளடக்கம் ;
}
முழு எண்ணாக முக்கிய ( ) {
நிலையான சரம் f_பெயர் = 'Sample.txt' ;
ஆட்டோ f_content = ReadFileFunc ( f_பெயர் ) ;
என்றால் ( f_content. உள்ளது_மதிப்பு ( ) ) {
கூட் << 'கோப்பின் உள்ளடக்கம்: \n ' << f_content. மதிப்பு ( ) << endl ;
} வேறு {
செர்ர் << 'பிழை: கோப்பு இங்கே திறக்கப்படவில்லை' << f_பெயர் << endl ;
}
திரும்ப 0 ;
}
வெளியீடு:
கொடுக்கப்பட்ட குறியீட்டின் விளைவாக 'வேறு' பகுதியில் நாம் சேர்த்த பிழை அறிக்கையை இங்கே காட்டுகிறது.
முடிவுரை
இந்த டுடோரியலில், 'std::optional' என்ற வலுவான C++ அம்சத்தை நாங்கள் ஆராய்ந்தோம், மேலும் இது விருப்ப மதிப்புகளைப் பிரதிநிதித்துவப்படுத்தும் தரப்படுத்தப்பட்ட முறையை வழங்குகிறது, பூஜ்ய குறிப்புகளுக்கான தேவையை நீக்கி தெளிவு மற்றும் குறியீட்டு பாதுகாப்பை மேம்படுத்துகிறது. சிக்கலான சிக்கல்களை விளக்கி, தவறுகளை கருணையுடன் கையாளும் திறனையும் இது மேம்படுத்துகிறது என்பதை அறிந்தோம்.