Exemplul 1:
Fișierele antet „opțional” și „iostream” sunt importate în acest cod. Trebuie să importam aceste fișiere de antet, astfel încât să putem accesa cu ușurință funcțiile care sunt definite în ele. După aceasta, includem „namespace std”, astfel încât să nu trebuie să-l introducem separat cu funcții precum „std::optional” și „std::cout”. Folosim „namespace std” aici. Deci, acum, plasăm „opțional” sau „cout” fără a tasta „std” cu ele.
Apoi, invocăm main() și plasăm „opțional” și îl setăm la „int” și declarăm „myNum”. Este sintaxa pentru declararea variabilei „std::optional”. Apoi, inițializam o altă variabilă numită „valoare” și atribuim o valoare variabilei „myNum” utilizând funcția value_or(). Trecem „99” în această funcție, așa că atribuie acest „99” variabilei „muNum” dacă nu există nicio valoare și o stochează în variabila „valoare”. Apoi, plasăm „cout” sub acesta, ceea ce ajută la afișarea valorii pe care am atribuit-o variabilei de deasupra acesteia.
Cod 1:
#include#include
folosind namespace std ;
int principal ( ) {
opțional < int > myNum ;
int valoare = myNum. valoare_sau ( 99 ) ;
cout << 'Valoarea numelui meu este: ' << valoare << endl ;
întoarcere 0 ;
}
Ieșire:
Aici, putem observa că este afișat „99”, ceea ce înseamnă că valoarea nu a fost prezentă mai sus și valoarea pe care am adăugat-o este atribuită acelei variabile.
Exemplul 2:
Mai întâi includem fișierele antet și plasăm „namespace std”. Acum, sub aceasta, declarăm funcția „std::optional” care este „divideFunc()”. „Dividendul” și „divizorul” sunt cei doi parametri ai acestei funcții. Apoi folosim „dacă” sub acesta, unde adăugăm o condiție care spune „divizor != 0”. Dacă acest lucru este satisfăcut, returnează răspunsul acestei diviziuni, deoarece adăugăm „întoarcere” în aceasta. În caz contrar, returnează „nullopt”, ceea ce înseamnă că nu există o valoare de tip sigur. Acum, invocăm main(). Pentru a deduce „std::optional”, plasăm „divideFunc()” și adăugăm „27, 3” în el și atribuim rezultatul variabilei „quotient”.
Aici, folosim cuvântul cheie „auto”, astfel încât să își ajusteze automat tipul de date. După aceasta, adăugăm „dacă” unde utilizăm „are-valoare” care determină dacă se primește o valoare de tip. Apoi, plasăm „cout” care redă rezultatul care este stocat în variabila „cot”, iar partea „altfel” conține o declarație care arată că divizorul este zero.
Cod 2:
#include#include
folosind namespace std ;
opțional < int > divideFunc ( int dividend , int separator ) {
dacă ( separator != 0 ) {
întoarcere dividend / separator ;
}
întoarcere nullopt ;
}
int principal ( ) {
auto coeficient = divideFunc ( 27 , 3 ) ;
dacă ( coeficient. are_valoare ( ) ) {
cout << 'Coeficientul este:' << coeficient. valoare ( ) << endl ;
} altfel {
cout << „Divizorul este zero aici” << endl ;
}
întoarcere 0 ;
}
Ieșire:
Ieșirea redă rezultatul după împărțire, ceea ce înseamnă că divizorul nu este zero. În acest caz, „std::optional” este utilizat pentru a determina dacă o valoare există sau nu în siguranță.
Exemplul 3:
Aici, declarăm variabila „std::optional” care este „numărul” din interiorul main(). Apoi, folosim „dacă” în care plasăm funcția has_value() cu această variabilă „număr”. Aceasta verifică dacă există sau nu o valoare în această variabilă „număr”. Dacă variabila „număr” conține o valoare, aceasta redă declarația pe care am adăugat-o după „dacă”. În caz contrar, redă declarația pe care am plasat-o după „altfel”.
Acum, inițializam „numărul” cu „92” și folosim din nou „dacă” sub acesta, unde funcția has_value() este adăugată cu variabila „număr” în „dacă ca condiție”. Aceasta determină dacă variabila „număr” are sau nu o valoare. Propoziția pe care o adăugăm după „dacă” este redată dacă variabila „număr” are o valoare. Dacă nu, este redată afirmația pe care o plasăm după „altfel”.
Cod 3:
#include#include
int principal ( ) {
std :: opțional < int > număr ;
dacă ( număr. are_valoare ( ) ) {
std :: cout << „Numărul este prezent:” << număr. valoare ( ) << std :: endl ;
} altfel {
std :: cout << „Numărul nu este prezent”. << std :: endl ;
}
număr = 92 ;
dacă ( număr. are_valoare ( ) ) {
std :: cout << „Numărul este prezent:” << număr. valoare ( ) << std :: endl ;
} altfel {
std :: cout << „Numărul nu este prezent”. << std :: endl ;
}
întoarcere 0 ;
}
Ieșire:
Aceasta redă partea „altfel” mai întâi, deoarece nu atribuim nicio valoare variabilei „std::optional”. Apoi, atribuim o valoare acestei variabile pentru a afișa acea valoare în rândul următor.
Exemplul 4:
Acum, declarăm trei variabile „std::optional” care sunt „n1”, „n2” și „n3”. De asemenea, atribuim valorile variabilelor „n2” și „n3”, care sunt „29” și, respectiv, „45”. Variabila „n1” a clasei „std::optional” este goală aici. Acum, folosim „boolalpha” care ajută la returnarea returnării în forma „adevărat” sau „fals”, mai degrabă decât „1” și „0”.
După aceasta, utilizăm operatorii relaționali dintre aceste variabile „std::optional” și plasăm fiecare instrucțiune în interiorul „cout”, astfel încât să redă și rezultatul comparației pe care am adăugat-o. Mai întâi, verifică că „n3 > n2”, apoi „n3 < n2”, „n1 < n2”, „n1 == std::nullopt”. Aici, „nullopt” este utilizat pentru a compara valoarea de tip no safe sau null. Apoi, verificăm separat „n2 == 49” și „n3 == 88” în interiorul declarației „cout”.
Cod 4:
#include#include
int principal ( )
{
std :: opțional < int > n1 ;
std :: opțional < int > n2 ( 29 ) ;
std :: opțional < int > n3 ( Patru cinci ) ;
std :: cout << std :: alfanumerice ;
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 == nul” << ( n1 == std :: nullopt ) << std :: endl ;
std :: cout << „N2 == 49” << ( n2 == 29 ) << std :: endl ;
std :: cout << „N3 == 88” << ( n3 == 88 ) << std :: endl ;
}
Ieșire:
Programul C++ pe care l-am menționat anterior compară diverse valori variabile de tipul „std::optional” în timp ce imprimă concomitent rezultatul în rezultat.
Exemplul 5:
Fișierele de antet care sunt incluse în acest cod sunt „iostream”, „fstream”, „opțional” și „șir”. „fstream” conține definiția ambelor funcții care sunt „ofstream” și „ifstream” de care avem nevoie în acest cod. Acum, includem „namespace std”, așa că nu îl plasăm separat cu fiecare funcție. Apoi, folosim „std:optional” și declarăm o funcție cu numele „ReadFileFunc” în care trecem „const string& f_Name” ca argument.
Apoi, avem „ifstream” care ajută la citirea fișierului al cărui nume va fi adăugat la variabila „f_name”. Apoi, folosim „dacă” în care includem condiția care spune că dacă fișierul nu este deschis, returnează „nullopt” așa cum l-am adăugat sub instrucțiunea „if”. Apoi, creăm o altă funcție care este „fileContent” care ajută la scrierea conținutului în fișier dacă fișierul este deschis. Aici, plasăm din nou „return fileContent” care returnează și conținutul pe care l-am adăugat la fișier după deschidere.
Acum, numim aici „main()” în care inițializam variabila „f_Name” cu numele fișierului „Sample.txt” pe care dorim să-l deschidem. Apoi, numim „ReadFileFunc()” aici și trecem variabila „f_Name” în această funcție care încearcă să citească fișierul și stochează conținutul acestuia în variabila „f_content”. Sub aceasta, folosim „has_value()” cu variabila „f_content” în „if”. Dacă această variabilă conține o valoare, o redă și pe măsură ce am adăugat „cout” sub „if” în care am plasat și „f_content”. În caz contrar, arată eroarea pe care am adăugat-o după „altfel”.
Cod 5:
#include#include
#include
#include <șir>
folosind namespace std ;
opțional < şir > ReadFileFunc ( const şir & f_Nume ) {
ifstream myFile ( f_Nume ) ;
dacă ( ! Dosarul meu. este deschis ( ) ) {
întoarcere nullopt ;
}
șir fișier conținut ( ( isstreambuf_iterator < char > ( Dosarul meu ) ) , isstreambuf_iterator < char > ( ) ) ;
întoarcere fişierConţinut ;
}
int principal ( ) {
const șir f_Nume = „Sample.txt” ;
auto f_conținut = ReadFileFunc ( f_Nume ) ;
dacă ( f_conținut. are_valoare ( ) ) {
cout << „Conținutul fișierului este: \n ' << f_conținut. valoare ( ) << endl ;
} altfel {
cerr << „Eroare: fișierul nu a fost deschis aici” << f_Nume << endl ;
}
întoarcere 0 ;
}
Ieșire:
Aici, arată declarația de eroare pe care am adăugat-o în partea „altfel” ca rezultat al codului dat.
Concluzie
În acest tutorial, am explorat caracteristica C++ puternică care este „std::optional” și am explicat că oferă o metodă standardizată de reprezentare a valorilor opționale, eliminând cerința referințelor nule și sporind claritatea și siguranța codului. Am învățat că îmbunătățește și abilitatea de a explica problemele complicate și de a trata greșelile cu grație.