Eksempel 1:
De 'valgfrie' og 'iostream'-headerfilerne importeres i denne kode. Vi skal importere disse header-filer, så vi nemt kan få adgang til de funktioner, der er defineret i dem. Herefter inkluderer vi 'navnerummet std', så vi ikke behøver at skrive det med funktioner separat som 'std::valgfrit' og 'std::cout'. Vi bruger 'navneområde std' her. Så nu placerer vi 'valgfrit' eller 'cout' uden at skrive 'std' med dem.
Derefter kalder vi main() og placerer 'valgfrit' og indstiller det til 'int' og erklærer 'mitNum'. Det er syntaksen til at erklære variablen 'std::valgfri'. Derefter initialiserer vi en anden variabel ved navn 'værdi' og tildeler en værdi til 'myNum'-variablen ved at bruge funktionen værdi_eller(). Vi sender '99' i denne funktion, så den tildeler denne '99' til 'muNum'-variablen, hvis der ikke er nogen værdi til stede, og gemmer den i 'værdi'-variablen. Derefter placerer vi 'cout' under dette, hvilket hjælper med at vise den værdi, vi tildelte variablen over den.
Kode 1:
#inkluder#include
bruger navneområde std ;
int vigtigste ( ) {
valgfri < int > mitNum ;
int værdi = mitNum. værdi_eller ( 99 ) ;
cout << 'Værdien af mitNum er: ' << værdi << endl ;
Vend tilbage 0 ;
}
Produktion:
Her kan vi bemærke, at '99' vises, hvilket betyder, at værdien ikke var til stede ovenfor, og den værdi, vi tilføjede, er tildelt den variabel.
Eksempel 2:
Vi inkluderer først header-filerne og placerer 'navneområdet std'. Nu, under dette, erklærer vi funktionen 'std::optional', som er 'divideFunc()'. 'Dividende' og 'divisor' er de to parametre for denne funktion. Vi bruger derefter 'hvis' under det, hvor vi tilføjer en betingelse, der siger 'divisior != 0'. Hvis dette er opfyldt, returnerer det svaret fra denne division, da vi tilføjer 'retur' i denne. Ellers returnerer det 'nullopt', hvilket betyder, at der ikke er nogen værdi af sikker type. Nu kalder vi main(). For at udlede til 'std::valgfrit', placerer vi 'divideFunc()' og tilføjer '27, 3' i den og tildeler resultatet til variablen 'kvotient'.
Her bruger vi nøgleordet 'auto', så det automatisk justerer sin datatype. Herefter tilføjer vi 'hvis', hvor vi bruger 'har-værdien', som afgør om en typeværdi modtages. Derefter placerer vi 'cout', som gengiver resultatet, der er gemt i 'kvotient'-variablen, og 'else'-delen indeholder en erklæring, der gengiver, at divisor er nul.
Kode 2:
#include#inkluder
bruger navneområde std ;
valgfri < int > divideFunc ( int udbytte , int skillevæg ) {
hvis ( skillevæg != 0 ) {
Vend tilbage udbytte / skillevæg ;
}
Vend tilbage nullopt ;
}
int vigtigste ( ) {
auto kvotient = divideFunc ( 27 , 3 ) ;
hvis ( kvotient. har_værdi ( ) ) {
cout << 'Kvoten er:' << kvotient. værdi ( ) << endl ;
} andet {
cout << 'Divisor er nul her' << endl ;
}
Vend tilbage 0 ;
}
Produktion:
Outputtet gengiver resultatet efter division, hvilket betyder, at divisor ikke er nul. I dette tilfælde bruges 'std::optional' til at bestemme, om en værdi eksisterer eller ikke typesikkert.
Eksempel 3:
Her erklærer vi 'std::optional'-variablen, som er 'tallet' inde i main(). Derefter bruger vi 'if', hvori vi placerer has_value()-funktionen med denne 'number'-variabel. Dette kontrollerer, om der er en værdi eller ej i denne 'tal'-variabel. Hvis 'number'-variablen indeholder en værdi, gengiver den sætningen, som vi tilføjede efter 'if'. Ellers gengiver den erklæringen, som vi placerede efter 'andet'.
Nu initialiserer vi 'number' med '92' og bruger 'if' igen under dette, hvor funktionen has_value() tilføjes med 'number'-variablen i 'if som betingelsen'. Dette bestemmer, om 'antal'-variablen har en værdi eller ej. Sætningen, som vi tilføjer efter 'hvis' gengives, hvis 'tal'-variablen har en værdi. Hvis ikke, gengives erklæringen, som vi placerer efter 'andet'.
Kode 3:
#include#inkluder
int vigtigste ( ) {
std :: valgfri < int > nummer ;
hvis ( nummer. har_værdi ( ) ) {
std :: cout << 'Nummeret er til stede:' << nummer. værdi ( ) << std :: endl ;
} andet {
std :: cout << 'Nummeret er ikke til stede.' << std :: endl ;
}
nummer = 92 ;
hvis ( nummer. har_værdi ( ) ) {
std :: cout << 'Nummeret er til stede:' << nummer. værdi ( ) << std :: endl ;
} andet {
std :: cout << 'Nummeret er ikke til stede.' << std :: endl ;
}
Vend tilbage 0 ;
}
Produktion:
Dette gengiver 'else'-delen først, fordi vi ikke tildeler nogen værdi til 'std::optional'-variablen. Derefter tildeler vi en værdi til denne variabel for at vise denne værdi i den næste linje.
Eksempel 4:
Nu erklærer vi tre 'std::valgfri' variable, som er 'n1', 'n2' og 'n3'. Vi tildeler også værdierne til 'n2' og 'n3' variabler, som er henholdsvis '29' og '45'. Variablen 'n1' i klassen 'std::optional' er tom her. Nu bruger vi 'boolalpha', som hjælper med at returnere returneringen i 'sand' eller 'falsk' form i stedet for '1' og '0'.
Herefter bruger vi de relationelle operatorer mellem disse 'std::valgfri' variabler og placerer hvert udsagn inde i 'cout', så det også ville gengive resultatet af den sammenligning, vi tilføjede. Først tjekker den, at 'n3 > n2', derefter 'n3 < n2', 'n1 < n2', 'n1 == std::nullopt '. Her bruges 'nullopt' til at sammenligne no safe-type-værdien eller null. Derefter tjekker vi 'n2 == 49' og 'n3 == 88' inde i 'cout'-sætningen separat.
Kode 4:
#inkluder#include
int vigtigste ( )
{
std :: valgfri < int > n1 ;
std :: valgfri < int > n2 ( 29 ) ;
std :: valgfri < int > n3 ( Fire. 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 == null' << ( 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 tidligere nævnte, sammenligner forskellige variabelværdier af typen 'std::optional' og udskriver samtidig resultatet til outputtet.
Eksempel 5:
Header-filerne, der er inkluderet i denne kode, er 'iostream', 'fstream', 'valgfri' og 'streng'. 'fstream' indeholder definitionen af begge funktioner, som er 'ofstream' og 'ifstream', som vi har brug for i denne kode. Nu inkluderer vi 'navneområdet std', så vi placerer det ikke separat med hver funktion. Derefter bruger vi 'std:optional' og erklærer en funktion med navnet 'ReadFileFunc', hvori vi sender 'const string& f_Name' som argument.
Så har vi 'ifstream', der hjælper med at læse filen, hvis navn vil blive tilføjet til variablen 'f_name'. Derefter bruger vi 'hvis', hvori vi inkluderer betingelsen, der siger, at hvis filen ikke åbnes, returnerer den 'nullopt', da vi tilføjede den under 'hvis'-sætningen. Derefter opretter vi en anden funktion, som er 'filindhold', der hjælper med at skrive indholdet til filen, hvis filen åbnes. Her placerer vi 'retur filindholdet' igen, som også returnerer det indhold, som vi tilføjede til filen efter åbning.
Nu kalder vi 'main()' her, hvor vi initialiserer variablen 'f_Name' med filnavnet 'Sample.txt', som vi vil åbne. Derefter kalder vi 'ReadFileFunc()' her og sender 'f_Name'-variablen i denne funktion, som forsøger at læse filen og gemmer dens indhold i 'f_content'-variablen. Under dette bruger vi 'has_value()' med variablen 'f_content' i 'if'. Hvis denne variabel indeholder en værdi, gengiver den den også, da vi tilføjede 'cout' under 'if', hvori vi også placerede 'f_content'. Ellers viser den fejlen, som vi tilføjede efter 'andet'.
Kode 5:
#include#include
#inkluder
#include
bruger navneområde std ;
valgfri < snor > ReadFileFunc ( konst snor & f_navn ) {
ifstream myFile ( f_navn ) ;
hvis ( ! min fil. er åben ( ) ) {
Vend tilbage nullopt ;
}
streng filindhold ( ( isstreambuf_iterator < char > ( min fil ) ) , isstreambuf_iterator < char > ( ) ) ;
Vend tilbage filindhold ;
}
int vigtigste ( ) {
konst streng f_navn = 'Sample.txt' ;
auto f_indhold = ReadFileFunc ( f_navn ) ;
hvis ( f_indhold. har_værdi ( ) ) {
cout << 'Indholdet af filen er: \n ' << f_indhold. værdi ( ) << endl ;
} andet {
cerr << 'Fejl: Filen er ikke åbnet her' << f_navn << endl ;
}
Vend tilbage 0 ;
}
Produktion:
Her viser den fejlsætningen, som vi tilføjede i 'andet'-delen som resultatet af den givne kode.
Konklusion
I denne tutorial udforskede vi den stærke C++-funktion, som er 'std::optional' og forklarede, at den tilbyder en standardiseret metode til at repræsentere de valgfrie værdier, hvilket gør op med kravet om nul-referencer og forbedrer klarhed og kodesikkerhed. Vi lærte, at det også forbedrer evnen til at forklare de komplicerede problemer og håndtere fejl med ynde.