C++ Std::Optioneel

C Std Optioneel



De functie “std::optioneel” is beschikbaar in C++17. De “std::optioneel” maakt een typeveilige representatie van optionele waarden mogelijk of een keuze om een ​​waarde te hebben. Een sjabloonklasse met de naam “std::optioneel” bevat een optionele waarde die wel of niet een geldige waarde kan bevatten. Het is een veiliger alternatief om de lege of optionele waarden weer te geven dan onbewerkte aanwijzingen of andere technieken. De “std::optioneel” minimaliseert de mogelijkheid van null-pointer-dereferentiefouten door van de gebruiker te eisen dat hij expliciet verifieert of een waarde bestaat voordat deze wordt opgehaald.

Voorbeeld 1:

De “optionele” en “iostream” headerbestanden worden in deze code geïmporteerd. We moeten deze headerbestanden importeren, zodat we gemakkelijk toegang hebben tot de functies die erin zijn gedefinieerd. Hierna voegen we de “naamruimte std” toe, zodat we deze niet apart hoeven te typen met functies zoals “std::optioneel” en “std::cout”. We gebruiken hier “namespace std”. Dus nu plaatsen we de “optioneel” of “cout” zonder “std” ermee te typen.

Vervolgens roepen we main() aan, plaatsen we “optioneel” en stellen we deze in op “int” en declareren we “myNum”. Het is de syntaxis voor het declareren van de variabele “std::optioneel”. Vervolgens initialiseren we een andere variabele met de naam 'value' en wijzen een waarde toe aan de variabele 'myNum' door de functie value_or() te gebruiken. We geven “99” door in deze functie, dus deze wijst deze “99” toe aan de variabele “muNum” als er geen waarde aanwezig is en slaat deze op in de variabele “waarde”. Vervolgens plaatsen we ‘cout’ eronder, wat helpt bij het weergeven van de waarde die we aan de variabele erboven hebben toegewezen.







Code1:

#include

#include

namespace std; gebruiken ;

int voornaamst ( ) {

optioneel < int > mijnNum ;

int waarde = mijnNum. waarde_of ( 99 ) ;

uit << 'De waarde van mijnNum is: ' << waarde << eindl ;

opbrengst 0 ;

}

Uitgang:



Hier kunnen we zien dat “99” wordt weergegeven, wat betekent dat de waarde hierboven niet aanwezig was en dat de waarde die we hebben toegevoegd aan die variabele is toegewezen.







Voorbeeld 2:

We nemen eerst de headerbestanden op en plaatsen de “namespace std”. Nu declareren we daaronder de functie “std::optioneel”, die de “divideFunc()” is. Het “dividend” en de “deler” zijn de twee parameters van deze functie. Vervolgens gebruiken we ‘if’ eronder, waar we een voorwaarde toevoegen die zegt: ‘divisior != 0’. Als hieraan is voldaan, wordt het antwoord van deze deling geretourneerd, terwijl we hier “return” aan toevoegen. Anders retourneert het “nullopt”, wat betekent dat er geen waarde van het veilige type is. Nu roepen we de main() aan. Om de “std::optioneel” af te leiden, plaatsen we “divideFunc()” en voegen er “27, 3” aan toe en wijzen het resultaat toe aan de “quotiënt” variabele.

Hier gebruiken we het trefwoord ‘auto’, zodat het gegevenstype automatisch wordt aangepast. Hierna voegen we de “if” toe, waarbij we de “has-value” gebruiken die bepaalt of een typewaarde wordt ontvangen. Vervolgens plaatsen we de ‘cout’ die de uitkomst weergeeft die is opgeslagen in de ‘quotiënt’-variabele, en het ‘else’-gedeelte bevat een verklaring die aangeeft dat de deler nul is.



Code2:

#include

#include

namespace std; gebruiken ;

optioneel < int > verdelenFunc ( int dividend , int scheidingslijn ) {

als ( scheidingslijn != 0 ) {

opbrengst dividend / scheidingslijn ;

}

opbrengst nulpunt ;

}

int voornaamst ( ) {

auto quotiënt = verdelenFunc ( 27 , 3 ) ;

als ( quotiënt. heeft_waarde ( ) ) {

uit << 'Het quotiënt is: ' << quotiënt. waarde ( ) << eindl ;

} anders {

uit << 'De deler is hier nul' << eindl ;

}

opbrengst 0 ;

}

Uitgang:

De uitvoer geeft het resultaat weer na deling, wat betekent dat de deler niet nul is. In dit geval wordt “std::optioneel” gebruikt om te bepalen of een waarde wel of niet typeveilig bestaat.

Voorbeeld 3:

Hier declareren we de “std::optioneel” variabele, het “nummer” binnen de main(). Vervolgens gebruiken we ‘if’ waarin we de functie has_value() plaatsen met deze ‘number’-variabele. Hiermee wordt gecontroleerd of er een waarde is of niet in deze “aantal” variabele. Als de variabele “number” een waarde bevat, wordt de instructie weergegeven die we na “if” hebben toegevoegd. Anders wordt de verklaring weergegeven die we na 'anders' hebben geplaatst.

Nu initialiseren we het 'getal' met '92' en gebruiken we 'if' opnieuw daaronder, waar de functie has_value() wordt toegevoegd met de variabele 'number' in de 'if' als voorwaarde. Dit bepaalt of de variabele “number” al dan niet een waarde heeft. De zin die we toevoegen na “if” wordt weergegeven als de variabele “number” een waarde heeft. Als dit niet het geval is, wordt de verklaring weergegeven die we na 'else' plaatsen.

Code 3:

#include

#include

int voornaamst ( ) {

soa :: optioneel < int > nummer ;

als ( nummer. heeft_waarde ( ) ) {

soa :: uit << 'Het nummer is aanwezig: ' << nummer. waarde ( ) << soa :: eindl ;

} anders {

soa :: uit << 'Het nummer is niet aanwezig.' << soa :: eindl ;

}

nummer = 92 ;

als ( nummer. heeft_waarde ( ) ) {

soa :: uit << 'Het nummer is aanwezig: ' << nummer. waarde ( ) << soa :: eindl ;

} anders {

soa :: uit << 'Het nummer is niet aanwezig.' << soa :: eindl ;

}

opbrengst 0 ;

}

Uitgang:

Hierdoor wordt eerst het gedeelte “else” weergegeven, omdat we geen enkele waarde toekennen aan de variabele “std::optioneel”. Vervolgens wijzen we een waarde toe aan deze variabele om die waarde op de volgende regel weer te geven.

Voorbeeld 4:

Nu declareren we drie “std::optioneel” variabelen, namelijk “n1”, “n2” en “n3”. We kennen ook de waarden toe aan de variabelen “n2” en “n3”, respectievelijk “29” en “45”. De variabele “n1” van de klasse “std::optioneel” is hier leeg. Nu gebruiken we de “boolalpha” die helpt bij het retourneren van de return in de “true” of “false” vorm in plaats van “1” en “0”.

Hierna gebruiken we de relationele operatoren tussen deze “std::optioneel” variabelen en plaatsen we elke instructie binnen de “cout” zodat deze ook het resultaat oplevert van de vergelijking die we hebben toegevoegd. Eerst wordt gecontroleerd of “n3 > n2”, vervolgens “n3 < n2”, “n1 < n2”, “n1 == std::nullopt ”. Hier wordt “nullopt” gebruikt voor het vergelijken van de waarde van het niet-veilige type of null. Vervolgens controleren we “n2 == 49” en “n3 == 88” afzonderlijk in de “cout”-instructie.

Code 4:

#include

#include

int voornaamst ( )

{

soa :: optioneel < int > n1 ;

soa :: optioneel < int > n2 ( 29 ) ;

soa :: optioneel < int > n3 ( Vier vijf ) ;

soa :: uit << soa :: alfanumeriek ;

soa :: uit << 'De n3 > n2' << ( n3 > n2 ) << soa :: eindl ;

soa :: uit << 'De n3 << ( n3 < n2 ) << soa :: eindl ;

soa :: uit << 'De n1 << ( n1 < n2 ) << soa :: eindl ;

soa :: uit << 'De n1 == nul ' << ( n1 == soa :: nulpunt ) << soa :: eindl ;

soa :: uit << 'De n2 == 49 ' << ( n2 == 29 ) << soa :: eindl ;

soa :: uit << 'De n3 == 88 ' << ( n3 == 88 ) << soa :: eindl ;

}

Uitgang:

Het C++-programma dat we eerder noemden, vergelijkt verschillende variabelewaarden van het type 'std::optioneel' terwijl tegelijkertijd de uitkomst naar de uitvoer wordt afgedrukt.

Voorbeeld 5:

De headerbestanden die in deze code zijn opgenomen, zijn “iostream”, “fstream”, “optioneel” en “string”. De “fstream” bevat de definitie van beide functies die “ofstream” en “ifstream” zijn die we in deze code nodig hebben. Nu nemen we de “namespace std” op, dus we plaatsen deze niet afzonderlijk bij elke functie. Vervolgens gebruiken we de “std:optioneel” en declareren we een functie met de naam “ReadFileFunc” waarin we “const string& f_Name” als argument doorgeven.

Dan hebben we “ifstream” dat helpt bij het lezen van het bestand waarvan de naam zal worden toegevoegd aan de “f_name” variabele. Vervolgens gebruiken we 'if' waarin we de voorwaarde opnemen die zegt dat als het bestand niet wordt geopend, het 'nullopt' retourneert zoals we het onder de 'if'-instructie hebben toegevoegd. Vervolgens maken we een andere functie, namelijk 'fileContent', die helpt bij het schrijven van de inhoud naar het bestand als het bestand wordt geopend. Hier plaatsen we opnieuw de “return fileContent”, die ook de inhoud retourneert die we na het openen aan het bestand hebben toegevoegd.

Nu noemen we hier de “main()” waarin we de “f_Name” variabele initialiseren met de “Sample.txt” bestandsnaam die we willen openen. Vervolgens roepen we hier de “ReadFileFunc()” aan en geven de variabele “f_Name” door aan deze functie, die probeert het bestand te lezen en de inhoud ervan op te slaan in de variabele “f_content”. Daaronder gebruiken we de “has_value()” met de “f_content” variabele in “if”. Als deze variabele een waarde bevat, wordt deze ook weergegeven omdat we de “cout” onder “if” hebben toegevoegd, waarin we ook de “f_content” hebben geplaatst. Anders wordt de fout weergegeven die we na 'else' hebben toegevoegd.

Code 5:

#include

#include

#include

#include

namespace std; gebruiken ;

optioneel < snaar > LeesBestandFunc ( const snaar & f_Naam ) {

ifstream mijnbestand ( f_Naam ) ;

als ( ! mijn bestand. is geopend ( ) ) {

opbrengst nulpunt ;

}

tekenreeksbestandInhoud ( ( isstreambuf_iterator < verkoold > ( mijn bestand ) ) , isstreambuf_iterator < verkoold > ( ) ) ;

opbrengst bestandInhoud ;

}

int voornaamst ( ) {

const tekenreeks f_Naam = 'Voorbeeld.txt' ;

auto f_inhoud = LeesBestandFunc ( f_Naam ) ;

als ( f_inhoud. heeft_waarde ( ) ) {

uit << 'De inhoud van het bestand is: \N ' << f_inhoud. waarde ( ) << eindl ;

} anders {

cerr << 'Fout: bestand hier niet geopend' << f_Naam << eindl ;

}

opbrengst 0 ;

}

Uitgang:

Hier wordt de foutverklaring weergegeven die we in het ‘else’-gedeelte hebben toegevoegd als resultaat van de gegeven code.

Conclusie

In deze tutorial hebben we de sterke C++-functie onderzocht die “std::optioneel” is en uitgelegd dat deze een gestandaardiseerde methode biedt voor het weergeven van de optionele waarden, waardoor de vereiste voor nulreferenties wordt afgeschaft en de duidelijkheid en codeveiligheid worden verbeterd. We hebben geleerd dat het ook het vermogen verbetert om ingewikkelde kwesties uit te leggen en met gratie om te gaan met fouten.