Esempio 1:
I file di intestazione 'opzionale' e 'iostream' vengono importati in questo codice. Dobbiamo importare questi file di intestazione in modo da poter accedere facilmente alle funzioni in essi definite. Successivamente, includiamo il 'namespace std' in modo da non doverlo digitare separatamente con funzioni come 'std::optional' e 'std::cout'. Usiamo 'namespace std' qui. Quindi, ora inseriamo “opzionale” o “cout” senza digitare “std” insieme ad essi.
Quindi, invochiamo main() e inseriamo 'opzionale', lo impostiamo su 'int' e dichiariamo 'myNum'. È la sintassi per dichiarare la variabile “std::optional”. Quindi, inizializziamo un'altra variabile denominata 'value' e assegniamo un valore alla variabile 'myNum' utilizzando la funzione value_or(). Passiamo '99' in questa funzione, quindi assegna questo '99' alla variabile 'muNum' se non è presente alcun valore e lo memorizza nella variabile 'value'. Quindi, posizioniamo 'cout' sotto questo che aiuta a visualizzare il valore che abbiamo assegnato alla variabile sopra di esso.
Codice 1:
#include#include
utilizzando lo spazio dei nomi std ;
int principale ( ) {
opzionale < int > mioNum ;
int valore = mioNum. valore_o ( 99 ) ;
cout << 'Il valore di mioNum è: ' << valore << fine ;
ritorno 0 ;
}
Produzione:
Qui possiamo notare che viene visualizzato '99', il che significa che il valore non era presente sopra e il valore che abbiamo aggiunto è assegnato a quella variabile.
Esempio 2:
Per prima cosa includiamo i file di intestazione e posizioniamo il 'namespace std'. Ora, sotto, dichiariamo la funzione “std::optional” che è “divideFunc()”. Il “dividendo” e il “divisore” sono i due parametri di questa funzione. Utilizziamo quindi 'se' sotto di esso dove aggiungiamo una condizione che dice 'divisore! = 0'. Se questo è soddisfatto, restituisce la risposta di questa divisione poiché aggiungiamo 'return' al suo interno. Altrimenti restituisce 'nullopt' che significa nessun valore di tipo sicuro. Ora invochiamo main(). Per dedurre 'std::optional', inseriamo 'divideFunc()' e aggiungiamo '27, 3' al suo interno e assegniamo il risultato alla variabile 'quoziente'.
Qui utilizziamo la parola chiave “auto” in modo che adatti automaticamente il suo tipo di dati. Successivamente, aggiungiamo il 'se' in cui utilizziamo il 'valore-ha' che determina se viene ricevuto un valore di tipo. Quindi, inseriamo il 'cout' che rende il risultato memorizzato nella variabile 'quotient' e la parte 'else' contiene un'istruzione che rende che il divisore è zero.
Codice 2:
#include#include
utilizzando lo spazio dei nomi std ;
opzionale < int > divideFunz ( int dividendo , int divisore ) {
Se ( divisore != 0 ) {
ritorno dividendo / divisore ;
}
ritorno nullopt ;
}
int principale ( ) {
auto quoziente = divideFunz ( 27 , 3 ) ;
Se ( quoziente. ha_valore ( ) ) {
cout << 'Il quoziente è: ' << quoziente. valore ( ) << fine ;
} altro {
cout << 'Qui il divisore è zero' << fine ;
}
ritorno 0 ;
}
Produzione:
L'output restituisce il risultato dopo la divisione, il che significa che il divisore non è zero. In questo caso, 'std::optional' viene utilizzato per determinare se un valore esiste o meno in modo sicuro.
Esempio 3:
Qui stiamo dichiarando la variabile “std::optional” che è il “numero” all'interno di main(). Quindi, utilizziamo 'if' in cui inseriamo la funzione has_value() con questa variabile 'numero'. Questo controlla se c'è un valore o meno in questa variabile 'numero'. Se la variabile “number” contiene un valore, restituisce l'istruzione che abbiamo aggiunto dopo “if”. Altrimenti, restituisce l'affermazione che abbiamo inserito dopo “else”.
Ora inizializziamo il 'numero' con '92' e utilizziamo di nuovo 'se' sotto dove la funzione has_value() viene aggiunta con la variabile 'numero' nel 'se come condizione'. Ciò determina se la variabile 'numero' ha o meno un valore. La frase che aggiungiamo dopo 'if' viene resa se la variabile 'numero' ha un valore. In caso contrario, viene resa l'affermazione che poniamo dopo “else”.
Codice 3:
#include#include
int principale ( ) {
standard :: opzionale < int > numero ;
Se ( numero. ha_valore ( ) ) {
standard :: cout << 'Il numero è presente: ' << numero. valore ( ) << standard :: fine ;
} altro {
standard :: cout << 'Il numero non è presente.' << standard :: fine ;
}
numero = 92 ;
Se ( numero. ha_valore ( ) ) {
standard :: cout << 'Il numero è presente: ' << numero. valore ( ) << standard :: fine ;
} altro {
standard :: cout << 'Il numero non è presente.' << standard :: fine ;
}
ritorno 0 ;
}
Produzione:
Ciò rende prima la parte 'else' perché non assegniamo alcun valore alla variabile 'std::optional'. Quindi, assegniamo un valore a questa variabile per visualizzare quel valore nella riga successiva.
Esempio 4:
Ora dichiariamo tre variabili “std::optional” che sono “n1”, “n2” e “n3”. Assegniamo anche i valori alle variabili “n2” e “n3” che sono rispettivamente “29” e “45”. La variabile “n1” della classe “std::optional” qui è vuota. Ora utilizziamo il “boolalfa” che aiuta a restituire il rendimento nella forma “vero” o “falso” anziché “1” e “0”.
Successivamente, utilizziamo gli operatori relazionali tra queste variabili 'std::optional' e inseriamo ciascuna istruzione all'interno di 'cout' in modo che restituisca anche il risultato del confronto che abbiamo aggiunto. Innanzitutto verifica che “n3 > n2”, quindi “n3 < n2”, “n1 < n2”, “n1 == std::nullopt ”. Qui, 'nullopt' viene utilizzato per confrontare il valore di tipo no-safe o null. Quindi controlliamo “n2 == 49” e “n3 == 88” all'interno dell'istruzione “cout” separatamente.
Codice 4:
#include#include
int principale ( )
{
standard :: opzionale < int > n1 ;
standard :: opzionale < int > n2 ( 29 ) ;
standard :: opzionale < int > n3 ( Quattro cinque ) ;
standard :: cout << standard :: alfanumerico ;
standard :: cout << 'Il n3 > n2' << ( n3 > n2 ) << standard :: fine ;
standard :: cout << 'Il n3 < n2' << ( n3 < n2 ) << standard :: fine ;
standard :: cout << 'Il n1 < n2 ' << ( n1 < n2 ) << standard :: fine ;
standard :: cout << 'Il n1 == nullo' << ( n1 == standard :: nullopt ) << standard :: fine ;
standard :: cout << 'Il n2 == 49' << ( n2 == 29 ) << standard :: fine ;
standard :: cout << 'Il n3 == 88' << ( n3 == 88 ) << standard :: fine ;
}
Produzione:
Il programma C++ che abbiamo menzionato in precedenza confronta vari valori di variabili del tipo 'std::optional' e contemporaneamente stampa il risultato sull'output.
Esempio 5:
I file di intestazione inclusi in questo codice sono 'iostream', 'fstream', 'opzionale' e 'string'. Il 'fstream' contiene la definizione di entrambe le funzioni che sono 'ofstream' e 'ifstream' di cui abbiamo bisogno in questo codice. Ora includiamo il 'namespace std', quindi non lo posizioniamo separatamente con ciascuna funzione. Quindi, utilizziamo 'std:optional' e dichiariamo una funzione con il nome 'ReadFileFunc' in cui passiamo 'const string& f_Name' come argomento.
Poi abbiamo “ifstream” che aiuta a leggere il file il cui nome verrà aggiunto alla variabile “f_name”. Quindi utilizziamo 'if' in cui includiamo la condizione che dice che se il file non è aperto, restituisce 'nullopt' poiché lo abbiamo aggiunto sotto l'istruzione 'if'. Quindi, creiamo un'altra funzione che è 'fileContent' che aiuta a scrivere il contenuto nel file se il file viene aperto. Qui inseriamo nuovamente il 'return fileContent' che restituisce anche il contenuto che abbiamo aggiunto al file dopo l'apertura.
Ora chiamiamo 'main()' qui in cui inizializziamo la variabile 'f_Name' con il nome del file 'Sample.txt' che vogliamo aprire. Quindi, chiamiamo qui 'ReadFileFunc()' e passiamo la variabile 'f_Name' in questa funzione che tenta di leggere il file e ne memorizza il contenuto nella variabile 'f_content'. Sotto questo, utilizziamo 'has_value()' con la variabile 'f_content' in 'if'. Se questa variabile contiene un valore, lo visualizza anche poiché abbiamo aggiunto 'cout' sotto 'if' in cui abbiamo inserito anche 'f_content'. Altrimenti mostra l'errore che abbiamo aggiunto dopo “else”.
Codice 5:
#include#include
#include
#include
utilizzando lo spazio dei nomi std ;
opzionale < corda > LeggiFileFunc ( cost corda & f_Nome ) {
ifstream mioFile ( f_Nome ) ;
Se ( ! il mio file. è aperto ( ) ) {
ritorno nullopt ;
}
stringa fileContenuto ( ( isstreambuf_iterator < car > ( il mio file ) ) , isstreambuf_iterator < car > ( ) ) ;
ritorno fileContenuto ;
}
int principale ( ) {
cost stringa f_Nome = 'Esempio.txt' ;
auto f_content = LeggiFileFunc ( f_Nome ) ;
Se ( f_content. ha_valore ( ) ) {
cout << 'Il contenuto del file è: \N ' << f_content. valore ( ) << fine ;
} altro {
cerr << 'Errore: file non aperto qui' << f_Nome << fine ;
}
ritorno 0 ;
}
Produzione:
Qui mostra la dichiarazione di errore che abbiamo aggiunto nella parte 'else' come risultato del codice fornito.
Conclusione
In questo tutorial, abbiamo esplorato la potente funzionalità C++ che è 'std::optional' e spiegato che offre un metodo standardizzato per rappresentare i valori opzionali, eliminando il requisito di riferimenti nulli e migliorando la chiarezza e la sicurezza del codice. Abbiamo imparato che migliora anche la capacità di spiegare questioni complicate e di affrontare gli errori con grazia.