ఉదాహరణ 1:
ఈ కోడ్‌లో “ఐచ్ఛికం” మరియు “iostream” హెడర్ ఫైల్‌లు దిగుమతి చేయబడ్డాయి. మేము ఈ హెడర్ ఫైల్‌లను తప్పనిసరిగా దిగుమతి చేసుకోవాలి, తద్వారా వాటిలో నిర్వచించబడిన ఫంక్షన్‌లను సులభంగా యాక్సెస్ చేయవచ్చు. దీని తర్వాత, మేము 'నేమ్‌స్పేస్ std'ని చేర్చుతాము కాబట్టి మేము దానిని 'std::optional' మరియు 'std::cout' వంటి ఫంక్షన్‌లతో ప్రత్యేకంగా టైప్ చేయనవసరం లేదు. మేము ఇక్కడ 'namespace std'ని ఉపయోగిస్తాము. కాబట్టి, ఇప్పుడు, మేము వాటితో 'std' అని టైప్ చేయకుండా 'ఐచ్ఛికం' లేదా 'cout'ని ఉంచుతాము.
అప్పుడు, మేము ప్రధాన()ని పిలుస్తాము మరియు 'ఐచ్ఛికం'గా ఉంచుతాము మరియు దానిని 'పూర్ణాంకానికి' సెట్ చేసి 'myNum'ని ప్రకటిస్తాము. ఇది “std:: optional” వేరియబుల్‌ని ప్రకటించడానికి వాక్యనిర్మాణం. అప్పుడు, మేము 'విలువ' పేరుతో మరొక వేరియబుల్‌ని ప్రారంభించాము మరియు value_or() ఫంక్షన్‌ని ఉపయోగించడం ద్వారా 'myNum' వేరియబుల్‌కు విలువను కేటాయిస్తాము. మేము ఈ ఫంక్షన్‌లో “99”ని పాస్ చేస్తాము, కాబట్టి విలువ లేనట్లయితే అది ఈ “99”ని “muNum” వేరియబుల్‌కి కేటాయిస్తుంది మరియు దానిని “value” వేరియబుల్‌లో నిల్వ చేస్తుంది. అప్పుడు, మేము దాని పైన ఉన్న వేరియబుల్‌కు కేటాయించిన విలువను ప్రదర్శించడంలో సహాయపడే “కౌట్” ను దీని కింద ఉంచుతాము.
కోడ్ 1:
# <ఐచ్ఛికం> చేర్చండి#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
int ప్రధాన ( ) {
ఐచ్ఛికం < int > myNum ;
int విలువ = myNum. విలువ_లేదా ( 99 ) ;
కోట్ << 'myNum విలువ:' << విలువ << endl ;
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, “99” ప్రదర్శించబడడాన్ని మనం గమనించవచ్చు, అంటే విలువ పైన లేదు మరియు మేము జోడించిన విలువ ఆ వేరియబుల్‌కు కేటాయించబడుతుంది.
ఉదాహరణ 2:
మేము మొదట హెడర్ ఫైల్‌లను చేర్చాము మరియు “నేమ్‌స్పేస్ std”ని ఉంచుతాము. ఇప్పుడు, దీని కింద, మేము 'std:: optional' ఫంక్షన్‌ని ప్రకటిస్తాము, అది 'divideFunc()'. 'డివిడెండ్' మరియు 'డివైజర్' ఈ ఫంక్షన్ యొక్క రెండు పారామితులు. మేము 'divisior != 0' అని చెప్పే షరతును జోడించే చోట దాని క్రింద 'if'ని ఉపయోగిస్తాము. ఇది సంతృప్తి చెందితే, మేము దీని లోపల “రిటర్న్” జోడించినప్పుడు అది ఈ విభజన యొక్క సమాధానాన్ని అందిస్తుంది. లేకపోతే, ఇది 'nullopt'ని అందిస్తుంది అంటే సురక్షిత-రకం విలువ లేదు. ఇప్పుడు, మేము ప్రధాన ()ని పిలుస్తాము. “std::optional”ని ఊహించడానికి, మేము “divideFunc()”ని ఉంచి, దానిలో “27, 3”ని జోడించి, ఫలితాన్ని “quotient” వేరియబుల్‌కి కేటాయిస్తాము.
ఇక్కడ, మేము “ఆటో” కీవర్డ్‌ని ఉపయోగిస్తాము కాబట్టి ఇది దాని డేటా రకాన్ని స్వయంచాలకంగా సర్దుబాటు చేస్తుంది. దీని తర్వాత, టైప్-విలువను స్వీకరించాలా వద్దా అని నిర్ణయించే 'has-value'ని ఉపయోగించుకునే 'if'ని జోడిస్తాము. అప్పుడు, మేము 'కోటెంట్' వేరియబుల్‌లో నిల్వ చేయబడిన ఫలితాన్ని అందించే 'కౌట్'ని ఉంచుతాము మరియు 'వేరే' భాగం డివైజర్ సున్నా అని రెండర్ చేసే స్టేట్‌మెంట్‌ను కలిగి ఉంటుంది.
కోడ్ 2:
## <ఐచ్ఛికం> చేర్చండి
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
ఐచ్ఛికం < int > divideFunc ( int డివిడెండ్ , int డివైడర్ ) {
ఉంటే ( డివైడర్ != 0 ) {
తిరిగి డివిడెండ్ / డివైడర్ ;
}
తిరిగి nullopt ;
}
int ప్రధాన ( ) {
దానంతట అదే గుణాత్మకమైన = divideFunc ( 27 , 3 ) ;
ఉంటే ( గుణాత్మకమైన. విలువ_ ఉంది ( ) ) {
కోట్ << 'కోషెంట్:' << గుణాత్మకమైన. విలువ ( ) << endl ;
} లేకపోతే {
కోట్ << 'డివైజర్ ఇక్కడ సున్నా' << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
అవుట్‌పుట్ విభజన తర్వాత ఫలితాన్ని అందిస్తుంది అంటే భాగహారం సున్నా కాదు. ఈ సందర్భంలో, విలువ ఉనికిలో ఉందో లేదో టైప్-సురక్షితంగా నిర్ధారించడానికి “std:: optional” ఉపయోగించబడుతుంది.
ఉదాహరణ 3:
ఇక్కడ, మేము 'std:: ఆప్షనల్' వేరియబుల్‌ని ప్రకటిస్తున్నాము, ఇది మెయిన్() లోపల ఉన్న 'సంఖ్య'. అప్పుడు, మేము ఈ “సంఖ్య” వేరియబుల్‌తో has_value() ఫంక్షన్‌ని ఉంచే “if”ని ఉపయోగిస్తాము. ఇది ఈ “సంఖ్య” వేరియబుల్‌లో విలువ ఉందో లేదో తనిఖీ చేస్తుంది. “సంఖ్య” వేరియబుల్ విలువను కలిగి ఉంటే, అది “if” తర్వాత మనం జోడించిన ప్రకటనను అందిస్తుంది. లేకపోతే, అది మనం “వేరే” తర్వాత ఉంచిన ప్రకటనను అందిస్తుంది.
ఇప్పుడు, మేము “92”తో “సంఖ్య”ను ప్రారంభించి, “If”ని మళ్లీ ఉపయోగించుకుంటాము, ఇక్కడ has_value() ఫంక్షన్‌ని “condition as the condition”లో “number” వేరియబుల్‌తో జోడించారు. ఇది “సంఖ్య” వేరియబుల్‌కు విలువ ఉందో లేదో నిర్ణయిస్తుంది. “సంఖ్య” వేరియబుల్‌కు విలువ ఉంటే, “if” తర్వాత మనం జోడించే వాక్యం రెండర్ చేయబడుతుంది. కాకపోతే, “వేరే” తర్వాత మనం ఉంచే స్టేట్‌మెంట్ రెండర్ చేయబడింది.
కోడ్ 3:
## <ఐచ్ఛికం> చేర్చండి
int ప్రధాన ( ) {
std :: ఐచ్ఛికం < int > సంఖ్య ;
ఉంటే ( సంఖ్య. విలువ_ ఉంది ( ) ) {
std :: కోట్ << 'సంఖ్య ఉంది:' << సంఖ్య. విలువ ( ) << std :: endl ;
} లేకపోతే {
std :: కోట్ << 'నంబర్ ప్రస్తుతం లేదు.' << std :: endl ;
}
సంఖ్య = 92 ;
ఉంటే ( సంఖ్య. విలువ_ ఉంది ( ) ) {
std :: కోట్ << 'సంఖ్య ఉంది:' << సంఖ్య. విలువ ( ) << std :: endl ;
} లేకపోతే {
std :: కోట్ << 'నంబర్ ప్రస్తుతం లేదు.' << std :: endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
'std::optional' వేరియబుల్‌కి మనం ఎటువంటి విలువను కేటాయించనందున ఇది ముందుగా 'else' భాగాన్ని రెండర్ చేస్తుంది. తరువాత, ఆ విలువను తదుపరి లైన్‌లో ప్రదర్శించడానికి మేము ఈ వేరియబుల్‌కు విలువను కేటాయిస్తాము.
ఉదాహరణ 4:
ఇప్పుడు, మేము 'n1', 'n2' మరియు 'n3' అనే మూడు 'std:: ఆప్షనల్' వేరియబుల్స్‌ని ప్రకటిస్తాము. మేము వరుసగా “29” మరియు “45” అయిన “n2” మరియు “n3” వేరియబుల్స్‌కు విలువలను కూడా కేటాయిస్తాము. “std::optional” క్లాస్ యొక్క “n1” వేరియబుల్ ఇక్కడ ఖాళీగా ఉంది. ఇప్పుడు, మేము '1' మరియు '0' కాకుండా 'నిజం' లేదా 'తప్పు' రూపంలో తిరిగి రావడానికి సహాయపడే 'బూలాల్ఫా'ని ఉపయోగిస్తాము.
దీని తర్వాత, మేము ఈ “std:: ఆప్షనల్” వేరియబుల్స్ మధ్య రిలేషనల్ ఆపరేటర్‌లను ఉపయోగిస్తాము మరియు ప్రతి స్టేట్‌మెంట్‌ను “కౌట్” లోపల ఉంచుతాము, కనుక ఇది మేము జోడించిన పోలిక ఫలితాన్ని కూడా అందిస్తుంది. మొదట, ఇది “n3 > n2”, ఆపై “n3 < n2”, “n1 < n2”, “n1 == std::nullopt ” అని తనిఖీ చేస్తుంది. ఇక్కడ, సురక్షిత-రకం విలువ లేదా శూన్యతను పోల్చడానికి “nullopt” ఉపయోగించబడుతుంది. అప్పుడు, మేము “కౌట్” స్టేట్‌మెంట్‌లో “n2 == 49” మరియు “n3 == 88”లను విడిగా తనిఖీ చేస్తాము.
కోడ్ 4:
# <ఐచ్ఛికం> చేర్చండి#
int ప్రధాన ( )
{
std :: ఐచ్ఛికం < int > n1 ;
std :: ఐచ్ఛికం < int > n2 ( 29 ) ;
std :: ఐచ్ఛికం < int > n3 ( నాలుగు ఐదు ) ;
std :: కోట్ << std :: ఆల్ఫాన్యూమరిక్ ;
std :: కోట్ << 'ది n3 > n2' << ( n3 > n2 ) << std :: endl ;
std :: కోట్ << 'ది n3 < n2' << ( n3 < n2 ) << std :: endl ;
std :: కోట్ << 'ది n1 < n2 ' << ( n1 < n2 ) << std :: endl ;
std :: కోట్ << 'ది n1 == శూన్యం' << ( n1 == std :: nullopt ) << std :: endl ;
std :: కోట్ << 'ది n2 == 49' << ( n2 == 29 ) << std :: endl ;
std :: కోట్ << 'ది n3 == 88' << ( n3 == 88 ) << std :: endl ;
}
అవుట్‌పుట్:
మేము మునుపు పేర్కొన్న C++ ప్రోగ్రామ్, ఫలితాన్ని ఏకకాలంలో అవుట్‌పుట్‌కి ప్రింట్ చేస్తున్నప్పుడు 'std:: ఆప్షనల్' రకం యొక్క వివిధ వేరియబుల్ విలువలను పోలుస్తుంది.
ఉదాహరణ 5:
ఈ కోడ్‌లో చేర్చబడిన హెడర్ ఫైల్‌లు “iostream”, “fstream”, “optional” మరియు “string”. “fstream” ఈ కోడ్‌లో మనకు అవసరమైన “ఆఫ్‌స్ట్రీమ్” మరియు “ifstream” అనే రెండు ఫంక్షన్‌ల నిర్వచనాన్ని కలిగి ఉంది. ఇప్పుడు, మేము 'నేమ్‌స్పేస్ std'ని చేర్చాము, కాబట్టి మేము దానిని ప్రతి ఫంక్షన్‌తో విడిగా ఉంచము. అప్పుడు, మేము “std:optional”ని ఉపయోగిస్తాము మరియు “ReadFileFunc” పేరుతో ఒక ఫంక్షన్‌ని ప్రకటిస్తాము, దీనిలో మేము “const string& f_Name”ని ఆర్గ్యుమెంట్‌గా పాస్ చేస్తాము.
అప్పుడు, 'f_name' వేరియబుల్‌కు పేరు జోడించబడే ఫైల్‌ను చదవడానికి సహాయపడే “ifstream” మాకు ఉంది. అప్పుడు, మేము 'if'ని ఉపయోగిస్తాము, దీనిలో ఫైల్ తెరవబడకపోతే, మేము దానిని 'if' స్టేట్‌మెంట్ క్రింద జోడించినప్పుడు అది 'nullopt'ని అందిస్తుంది. అప్పుడు, మేము ఫైల్ తెరిచినట్లయితే ఫైల్‌కు కంటెంట్‌ను వ్రాయడంలో సహాయపడే “ఫైల్‌కంటెంట్” అనే మరొక ఫంక్షన్‌ను సృష్టిస్తాము. ఇక్కడ, మేము 'రిటర్న్ ఫైల్ కంటెంట్'ని మళ్లీ ఉంచుతాము, ఇది తెరిచిన తర్వాత మేము ఫైల్‌కి జోడించిన కంటెంట్‌ను కూడా అందిస్తుంది.
ఇప్పుడు, మనం ఇక్కడ “main()” అని పిలుస్తాము, దీనిలో మనం తెరవాలనుకుంటున్న “Sample.txt” ఫైల్ పేరుతో “f_Name” వేరియబుల్‌ని ప్రారంభిస్తాము. అప్పుడు, మేము ఇక్కడ “ReadFileFunc()” అని పిలుస్తాము మరియు ఈ ఫంక్షన్‌లో “f_Name” వేరియబుల్‌ను పాస్ చేస్తాము, ఇది ఫైల్‌ను చదవడానికి ప్రయత్నిస్తుంది మరియు దాని కంటెంట్‌ను “f_content” వేరియబుల్‌లో నిల్వ చేస్తుంది. దీని కింద, మేము 'if'లో 'f_content' వేరియబుల్‌తో 'has_value()'ని ఉపయోగిస్తాము. ఈ వేరియబుల్ ఒక విలువను కలిగి ఉన్నట్లయితే, అది మనం 'f_content'ని కూడా ఉంచిన 'if' క్రింద 'cout'ని జోడించినప్పుడు కూడా దాన్ని రెండర్ చేస్తుంది. లేకుంటే, అది మనం 'else' తర్వాత జోడించిన లోపాన్ని చూపుతుంది.
కోడ్ 5:
##
# <ఐచ్ఛికం> చేర్చండి
#
నేమ్‌స్పేస్ stdని ఉపయోగిస్తోంది ;
ఐచ్ఛికం < స్ట్రింగ్ > ReadFileFunc ( స్థిరంగా స్ట్రింగ్ & f_పేరు ) {
ifstream myFile ( f_పేరు ) ;
ఉంటే ( ! myFile. తెరిచి ఉంది ( ) ) {
తిరిగి nullopt ;
}
స్ట్రింగ్ ఫైల్ కంటెంట్ ( ( isstreambuf_iterator < చార్ > ( myFile ) ) , isstreambuf_iterator < చార్ > ( ) ) ;
తిరిగి ఫైల్ కంటెంట్ ;
}
int ప్రధాన ( ) {
స్థిరంగా స్ట్రింగ్ f_Name = 'Sample.txt' ;
దానంతట అదే f_content = ReadFileFunc ( f_పేరు ) ;
ఉంటే ( f_content. విలువ_ ఉంది ( ) ) {
కోట్ << 'ఫైల్ యొక్క కంటెంట్: \n ' << f_content. విలువ ( ) << endl ;
} లేకపోతే {
cerr << 'లోపం: ఫైల్ ఇక్కడ తెరవబడలేదు' << f_పేరు << endl ;
}
తిరిగి 0 ;
}
అవుట్‌పుట్:
ఇక్కడ, మేము ఇచ్చిన కోడ్ యొక్క ఫలితం వలె 'else' భాగంలో జోడించిన దోష ప్రకటనను ఇది చూపుతుంది.
ముగింపు
ఈ ట్యుటోరియల్‌లో, మేము 'std:: ఐచ్ఛికం' అయిన బలమైన C++ ఫీచర్‌ని అన్వేషించాము మరియు ఇది ఐచ్ఛిక విలువలను సూచించే ప్రామాణిక పద్ధతిని అందజేస్తుందని, శూన్య సూచనల అవసరాన్ని తొలగించి, స్పష్టత మరియు కోడ్ భద్రతను పెంచుతుందని వివరించాము. ఇది సంక్లిష్టమైన సమస్యలను వివరించే సామర్థ్యాన్ని మరియు తప్పులను దయతో పరిష్కరించగల సామర్థ్యాన్ని కూడా మెరుగుపరుస్తుందని మేము తెలుసుకున్నాము.