Beispiel 1:
In diesem Code werden die Header-Dateien „optional“ und „iostream“ importiert. Wir müssen diese Header-Dateien importieren, damit wir problemlos auf die darin definierten Funktionen zugreifen können. Danach fügen wir den „Namespace std“ ein, damit wir ihn nicht separat mit Funktionen wie „std::optional“ und „std::cout“ eingeben müssen. Wir verwenden hier „namespace std“. Also platzieren wir jetzt „optional“ oder „cout“, ohne „std“ mit einzugeben.
Dann rufen wir main() auf und platzieren „optional“, setzen es auf „int“ und deklarieren „myNum“. Dies ist die Syntax zum Deklarieren der Variablen „std::optional“. Anschließend initialisieren wir eine weitere Variable mit dem Namen „value“ und weisen der Variablen „myNum“ mithilfe der Funktion value_or() einen Wert zu. Wir übergeben in dieser Funktion „99“, sodass diese „99“ der Variablen „muNum“ zugewiesen wird, wenn kein Wert vorhanden ist, und sie in der Variablen „value“ gespeichert wird. Dann platzieren wir „cout“ darunter, was dabei hilft, den Wert anzuzeigen, den wir der Variablen darüber zugewiesen haben.
Code 1:
#include#include
Verwenden des Namensraums std ;
int hauptsächlich ( ) {
Optional < int > meineNum ;
int Wert = meineNum. value_or ( 99 ) ;
cout << „Der Wert von myNum ist:“ << Wert << endl ;
zurückkehren 0 ;
}
Ausgabe:
Hier sehen wir, dass „99“ angezeigt wird, was bedeutet, dass der Wert oben nicht vorhanden war und der von uns hinzugefügte Wert dieser Variablen zugewiesen wird.
Beispiel 2:
Wir beziehen zunächst die Header-Dateien ein und platzieren den „Namespace std“. Darunter deklarieren wir nun die Funktion „std::optional“, die „divideFunc()“. „Dividende“ und „Divisor“ sind die beiden Parameter dieser Funktion. Wir verwenden dann „if“ darunter und fügen eine Bedingung hinzu, die „Divisor != 0“ lautet. Wenn dies erfüllt ist, wird die Antwort dieser Division zurückgegeben, da wir darin „return“ hinzufügen. Andernfalls wird „nullopt“ zurückgegeben, was bedeutet, dass kein Wert vom sicheren Typ vorhanden ist. Jetzt rufen wir main() auf. Um auf „std::optional“ zu schließen, platzieren wir „divideFunc()“, fügen „27, 3“ hinzu und weisen das Ergebnis der Variablen „quotient“ zu.
Hier verwenden wir das Schlüsselwort „auto“, damit der Datentyp automatisch angepasst wird. Danach fügen wir das „if“ hinzu, wobei wir den „has-value“ verwenden, der bestimmt, ob ein Typwert empfangen wird. Dann platzieren wir den „cout“, der das Ergebnis wiedergibt, das in der Variablen „quotient“ gespeichert ist, und der „else“-Teil enthält eine Anweisung, die angibt, dass der Divisor Null ist.
Code 2:
#include#include
Verwenden des Namensraums std ;
Optional < int > dividFunc ( int Dividende , int Teiler ) {
Wenn ( Teiler != 0 ) {
zurückkehren Dividende / Teiler ;
}
zurückkehren nullopt ;
}
int hauptsächlich ( ) {
Auto Quotient = dividFunc ( 27 , 3 ) ;
Wenn ( Quotient. has_value ( ) ) {
cout << „Der Quotient ist:“ << Quotient. Wert ( ) << endl ;
} anders {
cout << „Der Divisor ist hier Null“ << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Die Ausgabe gibt das Ergebnis nach der Division wieder, was bedeutet, dass der Divisor nicht Null ist. In diesem Fall wird „std::optional“ verwendet, um typsicher zu bestimmen, ob ein Wert vorhanden ist oder nicht.
Beispiel 3:
Hier deklarieren wir die Variable „std::optional“, die die „Zahl“ innerhalb von main() ist. Dann verwenden wir „if“, indem wir die Funktion has_value() mit dieser Variable „number“ platzieren. Dadurch wird überprüft, ob in dieser „Zahlen“-Variable ein Wert vorhanden ist oder nicht. Wenn die Variable „Zahl“ einen Wert enthält, gibt sie die Anweisung wieder, die wir nach „Wenn“ hinzugefügt haben. Andernfalls wird die Anweisung wiedergegeben, die wir nach „else“ platziert haben.
Jetzt initialisieren wir die „Zahl“ mit „92“ und verwenden darunter erneut „if“, wobei die Funktion has_value() mit der Variablen „number“ in „if als Bedingung“ hinzugefügt wird. Dadurch wird bestimmt, ob die Variable „Zahl“ einen Wert hat oder nicht. Der Satz, den wir nach „if“ hinzufügen, wird gerendert, wenn die Variable „number“ einen Wert hat. Wenn nicht, wird die Aussage wiedergegeben, die wir nach „else“ platzieren.
Code 3:
#include#include
int hauptsächlich ( ) {
std :: Optional < int > Nummer ;
Wenn ( Nummer. has_value ( ) ) {
std :: cout << „Die Nummer ist vorhanden:“ << Nummer. Wert ( ) << std :: endl ;
} anders {
std :: cout << „Die Nummer ist nicht vorhanden.“ << std :: endl ;
}
Nummer = 92 ;
Wenn ( Nummer. has_value ( ) ) {
std :: cout << „Die Nummer ist vorhanden:“ << Nummer. Wert ( ) << std :: endl ;
} anders {
std :: cout << „Die Nummer ist nicht vorhanden.“ << std :: endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Dadurch wird der „else“-Teil zuerst gerendert, da wir der Variablen „std::optional“ keinen Wert zuweisen. Dann weisen wir dieser Variablen einen Wert zu, um diesen Wert in der nächsten Zeile anzuzeigen.
Beispiel 4:
Jetzt deklarieren wir drei „std::optional“-Variablen: „n1“, „n2“ und „n3“. Wir weisen die Werte auch den Variablen „n2“ und „n3“ zu, also „29“ bzw. „45“. Die Variable „n1“ der Klasse „std::optional“ ist hier leer. Jetzt verwenden wir „boolalpha“, das dabei hilft, die Rückgabe in der „wahren“ oder „falschen“ Form anstelle von „1“ und „0“ zurückzugeben.
Danach verwenden wir die relationalen Operatoren zwischen diesen „std::optional“-Variablen und platzieren jede Anweisung innerhalb des „cout“, damit sie auch das Ergebnis des von uns hinzugefügten Vergleichs wiedergibt. Zuerst wird geprüft, ob „n3 > n2“, dann „n3 < n2“, „n1 < n2“, „n1 == std::nullopt“. Hier wird „nullopt“ zum Vergleichen des Werts „kein sicherer Typ“ oder „null“ verwendet. Dann überprüfen wir „n2 == 49“ und „n3 == 88“ innerhalb der „cout“-Anweisung separat.
Code 4:
#include#include
int hauptsächlich ( )
{
std :: Optional < int > n1 ;
std :: Optional < int > n2 ( 29 ) ;
std :: Optional < int > n3 ( Vier fünf ) ;
std :: cout << std :: alphanumerisch ;
std :: cout << „Das n3 > n2“ << ( n3 > n2 ) << std :: endl ;
std :: cout << „Das n3 < n2“ << ( n3 < n2 ) << std :: endl ;
std :: cout << „Das n1 < n2“ << ( n1 < n2 ) << std :: endl ;
std :: cout << „Das n1 == null“ << ( n1 == std :: nullopt ) << std :: endl ;
std :: cout << „Das n2 == 49“ << ( n2 == 29 ) << std :: endl ;
std :: cout << „Das n3 == 88“ << ( n3 == 88 ) << std :: endl ;
}
Ausgabe:
Das zuvor erwähnte C++-Programm vergleicht verschiedene Variablenwerte des Typs „std::optional“ und gibt gleichzeitig das Ergebnis in der Ausgabe aus.
Beispiel 5:
Die in diesem Code enthaltenen Header-Dateien sind „iostream“, „fstream“, „optional“ und „string“. Der „fstream“ enthält die Definition der beiden Funktionen „ofstream“ und „ifstream“, die wir in diesem Code benötigen. Jetzt schließen wir den „Namespace std“ ein, sodass wir ihn nicht bei jeder Funktion separat platzieren. Dann nutzen wir „std:optional“ und deklarieren eine Funktion mit dem Namen „ReadFileFunc“, in der wir „const string& f_Name“ als Argument übergeben.
Dann haben wir „ifstream“, das hilft, die Datei zu lesen, deren Name zur Variablen „f_name“ hinzugefügt wird. Dann verwenden wir „if“, indem wir die Bedingung einfügen, die besagt, dass die Datei „nullopt“ zurückgibt, wenn sie nicht geöffnet wird, wie wir sie unterhalb der „if“-Anweisung hinzugefügt haben. Dann erstellen wir eine weitere Funktion namens „fileContent“, die beim Schreiben des Inhalts in die Datei hilft, wenn die Datei geöffnet wird. Hier platzieren wir erneut den „return fileContent“, der auch den Inhalt zurückgibt, den wir der Datei nach dem Öffnen hinzugefügt haben.
Nun rufen wir hier „main()“ auf, in dem wir die Variable „f_Name“ mit dem Dateinamen „Sample.txt“ initialisieren, den wir öffnen möchten. Dann rufen wir hier „ReadFileFunc()“ auf und übergeben die Variable „f_Name“ in dieser Funktion, die versucht, die Datei zu lesen und ihren Inhalt in der Variablen „f_content“ zu speichern. Darunter verwenden wir „has_value()“ mit der Variablen „f_content“ in „if“. Wenn diese Variable einen Wert enthält, wird dieser auch gerendert, da wir „cout“ unter „if“ hinzugefügt haben, in dem wir auch „f_content“ platziert haben. Andernfalls wird der Fehler angezeigt, den wir nach „else“ hinzugefügt haben.
Code 5:
#include#include
#include
#include
Verwenden des Namensraums std ;
Optional < Zeichenfolge > ReadFileFunc ( const Zeichenfolge & f_Name ) {
ifstream myFile ( f_Name ) ;
Wenn ( ! meine Datei. ist offen ( ) ) {
zurückkehren nullopt ;
}
string fileContent ( ( isstreambuf_iterator < verkohlen > ( meine Datei ) ) , isstreambuf_iterator < verkohlen > ( ) ) ;
zurückkehren Dateiinhalt ;
}
int hauptsächlich ( ) {
const string f_Name = „Beispiel.txt“ ;
Auto f_content = ReadFileFunc ( f_Name ) ;
Wenn ( f_content. has_value ( ) ) {
cout << „Der Inhalt der Datei ist: \N ' << f_content. Wert ( ) << endl ;
} anders {
cerr << „Fehler: Datei hier nicht geöffnet“ << f_Name << endl ;
}
zurückkehren 0 ;
}
Ausgabe:
Hier wird die Fehleranweisung angezeigt, die wir im „else“-Teil als Ergebnis des angegebenen Codes hinzugefügt haben.
Abschluss
In diesem Tutorial haben wir die starke C++-Funktion „std::optional“ untersucht und erklärt, dass sie eine standardisierte Methode zur Darstellung der optionalen Werte bietet, wodurch die Anforderung für Nullreferenzen entfällt und die Klarheit und Codesicherheit verbessert wird. Wir haben gelernt, dass es auch die Fähigkeit verbessert, komplizierte Sachverhalte zu erklären und mit Fehlern elegant umzugehen.