Exempel 1:
De 'valfria' och 'iostream'-huvudfilerna importeras i den här koden. Vi måste importera dessa header-filer så att vi enkelt kan komma åt funktionerna som är definierade i dem. Efter detta inkluderar vi 'namnutrymmet std' så att vi inte behöver skriva det med funktioner separat som 'std::valfritt' och 'std::cout'. Vi använder 'namespace std' här. Så nu placerar vi 'valfritt' eller 'cout' utan att skriva 'std' med dem.
Sedan anropar vi main() och placerar 'valfritt' och ställer in det på 'int' och deklarerar 'myNum'. Det är syntaxen för att deklarera variabeln 'std::optional'. Sedan initierar vi en annan variabel som heter 'värde' och tilldelar ett värde till variabeln 'myNum' genom att använda funktionen value_or() . Vi skickar '99' i den här funktionen, så den tilldelar denna '99' till variabeln 'muNum' om det inte finns något värde och lagrar det i variabeln 'värde'. Sedan placerar vi 'cout' under detta, vilket hjälper till att visa värdet som vi tilldelade variabeln ovanför.
Kod 1:
#inkludera#include
använder namnutrymme std ;
int huvud ( ) {
frivillig < int > mittNum ;
int värde = mittNum. värde_eller ( 99 ) ;
cout << 'Värdet på myNum är: ' << värde << endl ;
lämna tillbaka 0 ;
}
Produktion:
Här kan vi märka att '99' visas vilket betyder att värdet inte fanns ovan och värdet som vi lade till är tilldelat den variabeln.
Exempel 2:
Vi inkluderar först rubrikfilerna och placerar 'namespace std'. Nu, under detta, deklarerar vi funktionen 'std::optional' som är 'divideFunc()'. 'Dividend' och 'divisor' är de två parametrarna för denna funktion. Vi använder sedan 'om' under det där vi lägger till ett villkor som säger 'divisior != 0'. Om detta är uppfyllt, returnerar det svaret från denna division när vi lägger till 'retur' i denna. Annars returnerar den 'nullopt' vilket betyder inget värde av säker typ. Nu anropar vi main(). För att sluta oss till 'std::valfritt', placerar vi 'divideFunc()' och lägger till '27, 3' i den och tilldelar resultatet till variabeln 'kvot'.
Här använder vi nyckelordet 'auto' så att det automatiskt justerar sin datatyp. Efter detta lägger vi till 'om' där vi använder 'har-värde' som avgör om ett typvärde tas emot. Sedan placerar vi 'cout' som återger utfallet som är lagrat i 'kvot'-variabeln, och 'annat'-delen innehåller ett uttalande som gör att divisorn är noll.
Kod 2:
#include#inkludera
använder namnutrymme std ;
frivillig < int > divideFunc ( int utdelning , int delare ) {
om ( delare != 0 ) {
lämna tillbaka utdelning / delare ;
}
lämna tillbaka nullopt ;
}
int huvud ( ) {
bil kvot = divideFunc ( 27 , 3 ) ;
om ( kvot. har_värde ( ) ) {
cout << 'Kvoten är:' << kvot. värde ( ) << endl ;
} annan {
cout << 'Divisorn är noll här' << endl ;
}
lämna tillbaka 0 ;
}
Produktion:
Utgången återger resultatet efter division vilket betyder att divisorn inte är noll. I det här fallet används 'std::optional' för att avgöra om ett värde finns eller inte typsäkert.
Exempel 3:
Här deklarerar vi variabeln 'std::optionell' som är 'numret' i main(). Sedan använder vi 'if' där vi placerar funktionen has_value() med denna 'number'-variabel. Detta kontrollerar om det finns ett värde eller inte i denna 'nummer'-variabel. Om variabeln 'number' innehåller ett värde, återger den påståendet som vi lade till efter 'if'. Annars återger det uttalandet som vi placerade efter 'annat'.
Nu initierar vi 'number' med '92' och använder 'if' igen under detta där funktionen has_value() läggs till med variabeln 'number' i 'if som villkor'. Detta avgör om variabeln 'number' har ett värde eller inte. Meningen som vi lägger till efter 'om' återges om variabeln 'number' har ett värde. Om inte, återges uttalandet som vi placerar efter 'annat'.
Kod 3:
#include#inkludera
int huvud ( ) {
std :: frivillig < int > siffra ;
om ( siffra. har_värde ( ) ) {
std :: cout << 'Numret finns:' << siffra. värde ( ) << std :: endl ;
} annan {
std :: cout << 'Numret finns inte.' << std :: endl ;
}
siffra = 92 ;
om ( siffra. har_värde ( ) ) {
std :: cout << 'Numret finns:' << siffra. värde ( ) << std :: endl ;
} annan {
std :: cout << 'Numret finns inte.' << std :: endl ;
}
lämna tillbaka 0 ;
}
Produktion:
Detta återger 'annat'-delen först eftersom vi inte tilldelar något värde till variabeln 'std::optional'. Sedan tilldelar vi ett värde till denna variabel för att visa det värdet på nästa rad.
Exempel 4:
Nu deklarerar vi tre 'std::optionella' variabler som är 'n1', 'n2' och 'n3'. Vi tilldelar också värdena till 'n2' och 'n3' variabler som är '29' respektive '45'. Variabeln 'n1' i klassen 'std::optional' är tom här. Nu använder vi 'boolalpha' som hjälper till att returnera avkastningen i 'sant' eller 'falsk' form snarare än '1' och '0'.
Efter detta använder vi relationsoperatorerna mellan dessa 'std::optionella' variabler och placerar varje påstående inuti 'cout' så att det också skulle återge resultatet av jämförelsen som vi lade till. Först kontrollerar den att 'n3 > n2', sedan 'n3 < n2', 'n1 < n2', 'n1 == std::nullopt '. Här används 'nullopt' för att jämföra noll-typens värde eller noll. Sedan kontrollerar vi 'n2 == 49' och 'n3 == 88' inuti 'cout'-satsen separat.
Kod 4:
#inkludera#include
int huvud ( )
{
std :: frivillig < int > n1 ;
std :: frivillig < int > n2 ( 29 ) ;
std :: frivillig < int > n3 ( Fyra fem ) ;
std :: cout << std :: alfanumerisk ;
std :: cout << 'N3 > n2' << ( n3 > n2 ) << std :: endl ;
std :: cout << 'N3 < n2' << ( n3 < n2 ) << std :: endl ;
std :: cout << 'N1 < n2' << ( n1 < n2 ) << std :: endl ;
std :: cout << 'N1 == noll' << ( n1 == std :: nullopt ) << std :: endl ;
std :: cout << 'N2 == 49' << ( n2 == 29 ) << std :: endl ;
std :: cout << 'N3 == 88' << ( n3 == 88 ) << std :: endl ;
}
Produktion:
C++-programmet som vi tidigare nämnde jämför olika variabelvärden av typen 'std::optional' samtidigt som resultatet skrivs ut till utdata.
Exempel 5:
Rubrikfilerna som ingår i den här koden är 'iostream', 'fstream', 'valfritt' och 'sträng'. 'fstream' innehåller definitionen av båda funktionerna som är 'ofstream' och 'ifstream' som vi behöver i den här koden. Nu inkluderar vi 'namnutrymmet std', så vi placerar det inte separat med varje funktion. Sedan använder vi 'std:optional' och deklarerar en funktion med namnet 'ReadFileFunc' där vi skickar 'const string& f_Name' som argument.
Sedan har vi 'ifstream' som hjälper till att läsa filen vars namn kommer att läggas till i variabeln 'f_name'. Sedan använder vi 'if' där vi inkluderar villkoret som säger att om filen inte öppnas, returnerar den 'nullopt' eftersom vi la till den under 'if'-satsen. Sedan skapar vi en annan funktion som är 'fileContent' som hjälper till att skriva innehållet till filen om filen öppnas. Här placerar vi 'return fileContent' igen som också returnerar innehållet som vi lagt till filen efter öppning.
Nu kallar vi 'main()' här där vi initierar variabeln 'f_Name' med filnamnet 'Sample.txt' som vi vill öppna. Sedan anropar vi 'ReadFileFunc()' här och skickar variabeln 'f_Name' i den här funktionen som försöker läsa filen och lagrar dess innehåll i variabeln 'f_content'. Under detta använder vi 'has_value()' med variabeln 'f_content' i 'if'. Om den här variabeln innehåller ett värde, återger den det också när vi lade till 'cout' under 'if' där vi också placerade 'f_content'. Annars visar det felet som vi lade till efter 'annat'.
Kod 5:
#include#inkludera
#inkludera
#inkludera
använder namnutrymme std ;
frivillig < sträng > ReadFileFunc ( konst sträng & f_Name ) {
ifstream myFile ( f_Name ) ;
om ( ! min fil. är öppen ( ) ) {
lämna tillbaka nullopt ;
}
sträng filinnehåll ( ( isstreambuf_iterator < röding > ( min fil ) ) , isstreambuf_iterator < röding > ( ) ) ;
lämna tillbaka filinnehåll ;
}
int huvud ( ) {
konst sträng f_Name = 'Sample.txt' ;
bil f_content = ReadFileFunc ( f_Name ) ;
om ( f_content. har_värde ( ) ) {
cout << 'Innehållet i filen är: \n ' << f_content. värde ( ) << endl ;
} annan {
cerr << 'Fel: Filen har inte öppnats här' << f_Name << endl ;
}
lämna tillbaka 0 ;
}
Produktion:
Här visar den felsatsen som vi lade till i 'annat'-delen som resultatet av den givna koden.
Slutsats
I den här handledningen utforskade vi den starka C++-funktionen som är 'std::optionell' och förklarade att den erbjuder en standardiserad metod för att representera de valfria värdena, vilket avskaffar kravet på nollreferenser och förbättrar tydlighet och kodsäkerhet. Vi lärde oss att det också förbättrar förmågan att förklara de komplicerade frågorna och hantera misstag med nåd.