Voorbeeld 1:
Hier is de “iostream” opgenomen, het headerbestand waarin verschillende functies worden gedeclareerd. We gebruiken deze functies die in dit headerbestand in onze code worden gedeclareerd, dus we nemen dit headerbestand op. Hierna hebben we de “std” die hier wordt geplaatst omdat functies als “cin” en “cout” er ook in worden gedefinieerd. We hoeven niet bij al deze functies “std” te typen als we de “namespace std” aan het begin van onze code toevoegen. Hierna wordt hier de functie “main()” aangeroepen, ook wel de drivercode van het C++-programma genoemd.
Vervolgens gebruiken we hier het trefwoord ‘try’, waarbij we ‘my_num1’ initialiseren met de waarde ‘35’. Het is hier de variabele van het gegevenstype ‘int’. Nu plaatsen we deze variabele binnen “if” en plaatsen we een voorwaarde die zegt dat “my_num1” groter moet zijn dan of gelijk is aan “98”. Als aan de gegeven voorwaarde is voldaan, gaat het verder binnen “if” en voert het de instructie uit die hier is geschreven. We gebruiken de “cout” en voegen een bericht in dat wordt weergegeven wanneer aan de voorwaarde is voldaan.
Hierna gebruiken we het zoekwoord ‘gooien’ na het plaatsen van ‘else’. In dit zoekwoord 'gooien' geven we 'mijn_num1' door als parameter. We voegen hieronder het gedeelte 'vangst' toe. We voegen “my_num2” in als de parameter van “catch()” en gebruiken vervolgens de “cout” opnieuw in dit “catch” -gedeelte. Dit deel wordt alleen uitgevoerd als er een uitzondering optreedt in het “try”-deel.
Code1:
#include
gebruik makend van naamruimte soa ;
int voornaamst ( ) {
poging {
int mijn_num1 = 35 ;
als ( mijn_num1 >= 98 ) {
uit << 'De toegang wordt hier verleend.' ;
} anders {
gooien ( mijn_num1 ) ;
}
}
vangst ( int mijn_num2 ) {
uit << 'De toegang wordt hier geweigerd.' << eindl ;
uit << 'Het nummer is: ' << mijn_num2 ;
}
opbrengst 0 ;
}
Uitgang:
Het getal dat we hebben ingevoerd is “35”, wat kleiner is dan “98”. De uitzondering treedt daar dus op en het gedeelte 'catch()' wordt weergegeven. De toegang tot het “try”-gedeelte wordt geweigerd.
Voorbeeld 2:
We plaatsen hier het headerbestand “iostream” en de “namespace std”. Hierna creëren we een functie “division()” waarin we twee parameters plaatsen die de “teller” en de “noemer” zijn van het gegevenstype “int”. We stellen het gegevenstype van deze ‘deling’-functie in op ‘dubbel’.
Daaronder voegen we “if()” toe, waarin we de voorwaarde toevoegen dat de noemer gelijk is aan nul. Hierna gebruiken we het trefwoord “gooien” en typen daar een bericht. Dit bericht wordt weergegeven wanneer de uitzondering in deze code voorkomt volgens de voorwaarde. Daaronder gebruiken we het trefwoord ‘return’ waarin we ‘teller/noemer’ plaatsen. Het retourneert dus het resultaat van de deling. Nu wordt de functie “main()” aangeroepen.
Hierna worden “num1” en “num2” geïnitialiseerd als de “int”-variabelen en wijzen er respectievelijk “89” en “0” aan toe. Vervolgens initialiseren we het “resultaat” van het “dubbele” gegevenstype. Hier gebruiken we het trefwoord ‘proberen’. In dit deel voegen we deze “resultaat” -variabele toe en wijzen we de functie “division()” toe aan deze variabele. We geven twee parameters door aan deze functie: “num1” en “num2”. Hieronder geven we het “resultaat” weer dat we krijgen na het toepassen van de functie “division()”. Hierna gebruiken we ook de “catch” en plaatsen we de “const char* msg” om het bericht weer te geven dat we eerder hebben toegevoegd.
Code2:
#includegebruik makend van naamruimte soa ;
dubbele divisie ( int teller, int noemer ) {
als ( noemer == 0 ) {
gooien 'Delen door nul is hier niet mogelijk!' ;
}
opbrengst ( teller / noemer ) ;
}
int voornaamst ( ) {
int num1 = 89 ;
int num2 = 0 ;
dubbele resultaat = 0 ;
poging {
resultaat = divisie ( num1, num2 ) ;
uit << resultaat << eindl ;
} vangst ( const verkoold * bericht ) {
cerr << bericht << eindl ;
}
opbrengst 0 ;
}
Uitgang:
Het getal dat we eerder als noemer hebben ingevoegd, is “0”. De uitzondering komt dus voor in de code en geeft het gegeven bericht weer.
Voorbeeld 3:
Hier wordt de functie “multiplication()” gemaakt, waarin we de “value” en “multiplier” plaatsen als de parameters van het gegevenstype “int”. Vervolgens gebruiken we 'als', waarbij we een vermenigvuldigingsvoorwaarde toevoegen die gelijk is aan nul. Vervolgens wordt “gooien” geplaatst waar we een verklaring toevoegen. Dan hebben we de “return” waar we de “value * multiplier” -variabelen plaatsen die we eerder hebben aangegeven. Het retourneert hier dus het resultaat van de vermenigvuldiging.
Hierna roepen we de “main()” aan, waarbij we de “int value1” en “int value2” declareren met respectievelijk de waarden “34” en “0”. De “int m_res” wordt ook gedeclareerd en wordt hier de functie “multiplication()” genoemd. Na het uitvoeren van deze functie wordt het resultaat nu opgeslagen in de variabele “m_res” en vervolgens weergegeven. Vervolgens gebruiken we de 'catch' -functie en voegen we het 'const char* msg' in om het bericht weer te geven dat we eerder hebben toegevoegd in het 'throw' -gedeelte.
Code 3:
#includegebruik makend van naamruimte soa ;
dubbele vermenigvuldiging ( int waarde , int vermenigvuldiger ) {
als ( vermenigvuldiger == 0 ) {
gooien 'We vermenigvuldigen de waarde niet met nul!' ;
}
opbrengst ( waarde * vermenigvuldiger ) ;
}
int voornaamst ( ) {
int waarde1 = 3. 4 ;
int waarde2 = 0 ;
int m_res ;
poging {
m_res = vermenigvuldiging ( waarde1, waarde2 ) ;
uit << m_res << eindl ;
} vangst ( const verkoold * bericht ) {
cerr << bericht << eindl ;
}
opbrengst 0 ;
}
Uitvoer :
Omdat de waarde die we eerder hebben ingevoerd “0” als vermenigvuldiger heeft, bevat de code een uitzondering waardoor de melding hier wordt weergegeven.
Voorbeeld 4:
Hier bouwen we de functie “multiply()” en geven we “number1” en “number2” door als de parameters van het gegevenstype “int”. Vervolgens gebruiken we de operator “if” om er een voorwaarde aan toe te voegen, namelijk een vermenigvuldiger die kleiner is dan of gelijk is aan nul. Daarna wordt de verklaring toegevoegd waar “gooien” hoort te zijn. Het resultaat van de vermenigvuldiging wordt vervolgens geretourneerd in de sectie 'return', waar we de variabele 'number1 * number2' invoegen die we eerder hebben gedeclareerd.
Vervolgens roepen we de functie “main()” aan en wijzen de waarden “34” en “12” toe aan respectievelijk “int newNumber1” en “int newNumber2”. Hier wordt de functie “multiply()” aangeroepen na de declaratie van het “int mResult”. De uitkomst van deze functie wordt nu opgeslagen in de variabele 'mResult' en wordt als volgt weergegeven. Vervolgens gebruiken we de functie 'catch' en voegen we het bericht 'const char* msg' toe om het bericht weer te geven dat we in de sectie 'throw' hebben geschreven.
Code 4:
#includegebruik makend van naamruimte soa ;
dubbele vermenigvuldigen ( int nummer 1 , int nummer 2 ) {
als ( nummer 2 <= 0 ) {
gooien 'We vermenigvuldigen de waarde niet met nul of een negatieve waarde!' ;
}
opbrengst ( nummer 1 * nummer 2 ) ;
}
int voornaamst ( ) {
int nieuwNum1 = 3. 4 ;
int nieuwNum2 = 12 ;
int mResultaat ;
poging {
mResultaat = vermenigvuldigen ( nieuwNum1, nieuwNum2 ) ;
uit << 'Het resultaat van vermenigvuldiging is' << mResultaat << eindl ;
}
vangst ( const verkoold * bericht ) {
cerr << bericht << eindl ;
}
opbrengst 0 ;
}
Uitgang:
De waarde die we toevoegen is “12” waaraan we de voorwaarde toevoegen. De functie “multiply()” wordt dus uitgevoerd omdat de voorwaarde niet waar is. Het resultaat van de vermenigvuldiging wordt weergegeven. Het “try”-gedeelte wordt hier uitgevoerd.
Conclusie
Het “try-catch”-concept en de codes in deze gids worden in detail bestudeerd. We hebben dit ‘try-catch’-concept grondig onderzocht en laten zien hoe het werkt in C++-programmeren. We hebben gedefinieerd dat de term ‘gooien’ een uitzondering creëert wanneer er een fout wordt gevonden, waardoor we onze unieke code kunnen schrijven. Met behulp van de “catch”-expressie kunnen we een codeblok specificeren dat moet worden uitgevoerd als er een uitzondering verschijnt in het “try”-gedeelte.