Primer 1:
Datoteki glave »izbirno« in »iostream« sta uvoženi v to kodo. Te datoteke glave moramo uvoziti, da lahko enostavno dostopamo do funkcij, ki so v njih definirane. Po tem vključimo »namespace std«, tako da nam ga ni treba vnašati ločeno s funkcijami, kot sta »std::optional« in »std::cout«. Tukaj uporabljamo »namespace std«. Torej, zdaj postavimo 'optional' ali 'cout', ne da bi z njima vtipkali 'std'.
Nato pokličemo main() in postavimo »optional« ter ga nastavimo na »int« in deklariramo »myNum«. To je sintaksa za deklaracijo spremenljivke »std::optional«. Nato inicializiramo drugo spremenljivko z imenom »value« in dodelimo vrednost spremenljivki »myNum« z uporabo funkcije value_or(). V tej funkciji posredujemo »99«, tako da ta »99« dodeli spremenljivki »muNum«, če ni prisotne vrednosti, in jo shrani v spremenljivko »value«. Nato pod to postavimo »cout«, kar pomaga pri prikazu vrednosti, ki smo jo dodelili spremenljivki nad njim.
Koda 1:
#include#include
uporaba imenskega prostora std ;
int glavni ( ) {
neobvezno < int > myNum ;
int vrednost = myNum. vrednost_ali ( 99 ) ;
cout << 'Vrednost myNum je: ' << vrednost << konec ;
vrnitev 0 ;
}
Izhod:
Tukaj lahko opazimo, da je prikazano »99«, kar pomeni, da vrednosti ni bilo zgoraj in da je vrednost, ki smo jo dodali, dodeljena tej spremenljivki.
Primer 2:
Najprej vključimo datoteke glave in postavimo »namespace std«. Zdaj, pod tem, deklariramo funkcijo 'std::optional', ki je 'divideFunc()'. Parametra te funkcije sta »dividenda« in »delitelj«. Nato pod njim uporabimo »if«, kjer dodamo pogoj, ki pravi »divisior != 0«. Če je to izpolnjeno, vrne odgovor te delitve, ko znotraj tega dodamo »return«. V nasprotnem primeru vrne »nullopt«, kar pomeni, da ni vrednosti varnega tipa. Zdaj pokličemo main(). Za sklepanje na »std::optional« postavimo »divideFunc()« in vanj dodamo »27, 3« ter rezultat dodelimo spremenljivki »kvocient«.
Tukaj uporabljamo ključno besedo »samodejno«, tako da samodejno prilagodi vrsto podatkov. Po tem dodamo »if«, kjer uporabimo »has-value«, ki določa, ali je tipska vrednost prejeta. Nato postavimo »cout«, ki upodobi izid, ki je shranjen v spremenljivki »kvocient«, del »else« pa vsebuje izjavo, ki upodobi, da je delitelj nič.
Koda 2:
#include#include
uporaba imenskega prostora std ;
neobvezno < int > divideFunc ( int dividenda , int delilnik ) {
če ( delilnik != 0 ) {
vrnitev dividenda / delilnik ;
}
vrnitev nullopt ;
}
int glavni ( ) {
avto količnik = divideFunc ( 27 , 3 ) ;
če ( količnik. has_value ( ) ) {
cout << 'Količnik je:' << količnik. vrednost ( ) << konec ;
} drugače {
cout << 'Delitelj je tukaj nič' << konec ;
}
vrnitev 0 ;
}
Izhod:
Izhod upodobi rezultat po deljenju, kar pomeni, da delitelj ni nič. V tem primeru se uporabi »std::optional« za ugotavljanje, ali vrednost obstaja ali ne varno tipka.
Primer 3:
Tukaj deklariramo spremenljivko »std::optional«, ki je »število« znotraj main(). Nato uporabimo »if«, v katerega postavimo funkcijo has_value() s to spremenljivko »number«. To preveri, ali je v tej spremenljivki »število« vrednost ali ne. Če spremenljivka »number« vsebuje vrednost, upodobi stavek, ki smo ga dodali za »if«. V nasprotnem primeru upodobi stavek, ki smo ga postavili za 'drugo'.
Zdaj inicializiramo »število« z »92« in znova uporabimo »če« pod tem, kjer je dodana funkcija has_value() s spremenljivko »število« v »če kot pogoj«. To določa, ali ima spremenljivka »število« vrednost ali ne. Stavek, ki ga dodamo za 'if', je upodobljen, če ima spremenljivka 'number' vrednost. Če ne, se upodobi stavek, ki ga postavimo za 'drugo'.
Koda 3:
#include#include
int glavni ( ) {
std :: neobvezno < int > število ;
če ( število. has_value ( ) ) {
std :: cout << 'Številka je prisotna: ' << število. vrednost ( ) << std :: konec ;
} drugače {
std :: cout << 'Številka ni prisotna.' << std :: konec ;
}
število = 92 ;
če ( število. has_value ( ) ) {
std :: cout << 'Številka je prisotna: ' << število. vrednost ( ) << std :: konec ;
} drugače {
std :: cout << 'Številka ni prisotna.' << std :: konec ;
}
vrnitev 0 ;
}
Izhod:
To najprej upodobi del »else«, ker spremenljivki »std::optional« ne dodelimo nobene vrednosti. Nato tej spremenljivki dodelimo vrednost za prikaz te vrednosti v naslednji vrstici.
Primer 4:
Zdaj deklariramo tri spremenljivke »std::optional«, ki so »n1«, »n2« in »n3«. Vrednosti dodelimo tudi spremenljivkama »n2« in »n3«, ki sta »29« oziroma »45«. Spremenljivka »n1« razreda »std::optional« je tukaj prazna. Zdaj uporabljamo »boolalpha«, ki pomaga pri vračanju v obliki »true« ali »false« namesto »1« in »0«.
Po tem uporabimo relacijske operaterje med temi spremenljivkami »std::optional« in vsak stavek postavimo znotraj »cout«, da bi tudi upodobil rezultat primerjave, ki smo jo dodali. Najprej preveri, ali je »n3 > n2«, nato »n3 < n2«, »n1 < n2«, »n1 == std::nullopt«. Tukaj se »nullopt« uporablja za primerjavo vrednosti brez varnega tipa ali vrednosti nič. Nato ločeno preverimo »n2 == 49« in »n3 == 88« v stavku »cout«.
Koda 4:
#include#include
int glavni ( )
{
std :: neobvezno < int > n1 ;
std :: neobvezno < int > n2 ( 29 ) ;
std :: neobvezno < int > n3 ( Štiri ) ;
std :: cout << std :: alfanumerično ;
std :: cout << 'N3 > n2' << ( n3 > n2 ) << std :: konec ;
std :: cout << 'N3 < n2' << ( n3 < n2 ) << std :: konec ;
std :: cout << 'N1 < n2' << ( n1 < n2 ) << std :: konec ;
std :: cout << 'N1 == nič' << ( n1 == std :: nullopt ) << std :: konec ;
std :: cout << 'N2 == 49' << ( n2 == 29 ) << std :: konec ;
std :: cout << 'N3 == 88' << ( n3 == 88 ) << std :: konec ;
}
Izhod:
Program C++, ki smo ga prej omenili, primerja različne vrednosti spremenljivk tipa »std::optional«, medtem ko sočasno natisne rezultat v izhod.
Primer 5:
Datoteke glave, ki so vključene v to kodo, so »iostream«, »fstream«, »optional« in »string«. 'fstream' vsebuje definicijo obeh funkcij, ki sta 'ofstream' in 'ifstream', ki ju potrebujemo v tej kodi. Zdaj smo vključili 'namespace std', tako da ga ne postavimo ločeno z vsako funkcijo. Nato uporabimo »std:optional« in deklariramo funkcijo z imenom »ReadFileFunc«, v kateri kot argument posredujemo »const string& f_Name«.
Nato imamo »ifstream«, ki pomaga prebrati datoteko, katere ime bo dodano spremenljivki »f_name«. Nato uporabimo »if«, v katerega vključimo pogoj, ki pravi, da če datoteka ni odprta, vrne »nullopt«, kot smo ga dodali pod izjavo »if«. Nato ustvarimo še eno funkcijo, ki je 'fileContent', ki pomaga pri zapisovanju vsebine v datoteko, če je datoteka odprta. Tukaj znova postavimo »return fileContent«, ki prav tako vrne vsebino, ki smo jo dodali v datoteko po odprtju.
Zdaj tukaj pokličemo »main()«, v katerem inicializiramo spremenljivko »f_Name« z imenom datoteke »Sample.txt«, ki jo želimo odpreti. Nato tukaj pokličemo »ReadFileFunc()« in tej funkciji posredujemo spremenljivko »f_Name«, ki poskuša prebrati datoteko in shrani njeno vsebino v spremenljivko »f_content«. Pod tem uporabljamo »has_value()« s spremenljivko »f_content« v »if«. Če ta spremenljivka vsebuje vrednost, jo tudi upodobi, saj smo dodali »cout« pod »if«, v katerega smo postavili tudi »f_content«. V nasprotnem primeru prikaže napako, ki smo jo dodali za »drugo«.
Koda 5:
#include#include
#include
#include
uporaba imenskega prostora std ;
neobvezno < vrvica > ReadFileFunc ( konst vrvica & f_Ime ) {
ifstream myFile ( f_Ime ) ;
če ( ! mojaDatoteka. je_odprto ( ) ) {
vrnitev nullopt ;
}
string fileContent ( ( isstreambuf_iterator < char > ( mojaDatoteka ) ) , isstreambuf_iterator < char > ( ) ) ;
vrnitev fileContent ;
}
int glavni ( ) {
konst niz f_Name = 'Vzorec.txt' ;
avto f_vsebina = ReadFileFunc ( f_Ime ) ;
če ( f_vsebina. has_value ( ) ) {
cout << 'Vsebina datoteke je: \n ' << f_vsebina. vrednost ( ) << konec ;
} drugače {
cerr << 'Napaka: datoteka ni odprta tukaj' << f_Ime << konec ;
}
vrnitev 0 ;
}
Izhod:
Tukaj prikazuje izjavo o napaki, ki smo jo dodali v del »drugo« kot rezultat dane kode.
Zaključek
V tej vadnici smo raziskali močno funkcijo C++, ki je »std::optional«, in pojasnili, da ponuja standardizirano metodo za predstavitev izbirnih vrednosti, s čimer odpravimo zahtevo po ničelnih sklicih in povečamo jasnost in varnost kode. Izvedeli smo, da tudi izboljša zmožnost razlage zapletenih vprašanj in spoprijemanja z napakami.