Exempel 1:
'iostream' ingår här, rubrikfilen där flera funktioner deklareras. Vi använder dessa funktioner som deklareras i denna rubrikfil i vår kod, så vi inkluderar denna rubrikfil. Efter detta har vi 'std' som placeras här eftersom funktioner som 'cin' och 'cout' också definieras i den. Vi behöver inte skriva 'std' med alla dessa funktioner om vi lägger till 'namespace std' i början av vår kod. Efter detta anropas funktionen 'main()' här som också kallas för C++-programmets drivrutinskod.
Sedan använder vi nyckelordet 'prova' här där vi initialiserar 'mitt_nummer1' med värdet '35'. Det är datatypvariabeln 'int' här. Nu placerar vi denna variabel inuti 'om' och placerar ett villkor som säger att 'mitt_nummer1' måste vara större än eller lika med '98'. Om det givna villkoret är uppfyllt, går det framåt i 'if' och exekverar påståendet som är skrivet här. Vi använder 'cout' och infogar ett meddelande som ska visas när villkoret är uppfyllt.
Efter detta använder vi nyckelordet 'kasta' efter att ha placerat 'annat'. I det här nyckelordet 'kasta' skickar vi 'mitt_nummer1' som parameter. Vi lägger till 'fångst'-delen under detta. Vi infogar 'my_num2' som parametern för 'catch()' och använder sedan 'cout' igen inuti denna 'catch'-del. Den här delen körs endast när ett undantag inträffar i 'försök'-delen.
Kod 1:
#include
använder sig av namnutrymme std ;
int huvud ( ) {
Prova {
int mitt_nummer1 = 35 ;
om ( mitt_nummer1 >= 98 ) {
cout << 'Tillträdet beviljas här.' ;
} annan {
kasta ( mitt_nummer1 ) ;
}
}
fånga ( int mitt_nummer2 ) {
cout << 'Tillträdet nekas här.' << endl ;
cout << 'Numret är:' << mitt_nummer2 ;
}
lämna tillbaka 0 ;
}
Produktion:
Siffran som vi angav är '35', vilket är mindre än '98'. Så undantaget inträffar där och 'catch()'-delen visas. Åtkomsten till 'försök'-delen nekas.
Exempel 2:
Vi placerar 'iostream'-huvudfilen här och 'namespace std'. Efter detta skapar vi en 'division()'-funktion där vi placerar två parametrar som är 'täljaren' och 'nämnaren' för datatypen 'int'. Vi ställer in datatypen för denna 'division'-funktion till 'dubbel'.
Under detta lägger vi till 'if()' där vi lägger till villkoret att nämnaren är lika med noll. Efter detta använder vi nyckelordet 'kasta' och skriver ett meddelande där. Detta meddelande återges när undantaget inträffar i den här koden enligt villkoret. Under detta använder vi nyckelordet 'retur' där vi placerar 'täljare/nämnare'. Så det returnerar resultatet av divisionen. Nu anropas funktionen 'main()'.
Efter detta initieras 'num1' och 'num2' som 'int'-variablerna och tilldelar '89' respektive '0' till dem. Sedan initierar vi 'resultatet' för den 'dubbla' datatypen. Här använder vi nyckelordet 'prova'. I den här delen lägger vi till denna 'resultat'-variabel och tilldelar 'division()'-funktionen till denna variabel. Vi skickar två parametrar till denna funktion: 'num1' och 'num2'. Under detta visar vi 'resultatet' som vi får efter att ha tillämpat funktionen 'division()'. Efter detta använder vi också 'catch' och placerar 'const char* msg' för att visa meddelandet som vi tidigare lagt till.
Kod 2:
#includeanvänder sig av namnutrymme std ;
dubbel division ( int täljare, int nämnare ) {
om ( nämnare == 0 ) {
kasta 'Division med noll är inte möjlig här!' ;
}
lämna tillbaka ( täljare / nämnare ) ;
}
int huvud ( ) {
int nummer1 = 89 ;
int nummer2 = 0 ;
dubbel resultat = 0 ;
Prova {
resultat = division ( nummer1, nummer2 ) ;
cout << resultat << endl ;
} fånga ( konst röding * medd ) {
cerr << medd << endl ;
}
lämna tillbaka 0 ;
}
Produktion:
Siffran som vi tidigare infogat som nämnare är '0'. Så undantaget förekommer i koden och det visar det givna meddelandet.
Exempel 3:
Funktionen 'multiplication()' skapas här där vi placerar 'värde' och 'multiplikator' som parametrar för datatypen 'int'. Sedan använder vi 'om' där vi adderar ett multiplikatorvillkor som är lika med noll. Sedan placeras 'kast' där vi lägger till ett uttalande. Sedan har vi 'return' där vi placerar 'värde * multiplikator'-variablerna som vi tidigare deklarerat. Så det returnerar multiplikationsresultatet här.
Efter detta kallar vi 'main()' där vi deklarerar 'int value1' och 'int value2' med värdena '34' respektive '0'. 'int m_res' deklareras också och kallas sedan för 'multiplication()'-funktionen här. Efter att ha utfört denna funktion sparas nu resultatet i variabeln 'm_res' och visas sedan. Därefter använder vi 'catch'-funktionen och infogar 'const char* msg' för att visa meddelandet som vi tidigare lagt till i 'throw'-delen.
Kod 3:
#includeanvänder sig av namnutrymme std ;
dubbel multiplikation ( int värde , int multiplikator ) {
om ( multiplikator == 0 ) {
kasta 'Vi multiplicerar inte värdet med noll!' ;
}
lämna tillbaka ( värde * multiplikator ) ;
}
int huvud ( ) {
int värde1 = 3. 4 ;
int värde2 = 0 ;
int m_res ;
Prova {
m_res = multiplikation ( värde1, värde2 ) ;
cout << m_res << endl ;
} fånga ( konst röding * medd ) {
cerr << medd << endl ;
}
lämna tillbaka 0 ;
}
Produktion :
Eftersom värdet som vi tidigare angett har '0' som multiplikator, har koden ett undantag som gör att meddelandet visas här.
Exempel 4:
Här bygger vi funktionen 'multiply()' och skickar in 'number1' och 'number2' som parametrarna för datatypen 'int'. Därefter använder vi 'om'-operatorn för att lägga till ett villkor till den som är en multiplikator som är mindre än eller lika med noll. Efter det läggs påståendet till där 'kast' ska vara. Multiplikationsresultatet returneras sedan i 'retur'-sektionen där vi infogar variabeln 'number1 * number2' som vi tidigare deklarerat.
Därefter anropar vi funktionen 'main()' och tilldelar värdena '34' och '12' till 'int newNumber1' respektive 'int newNumber2'. Här anropas funktionen 'multiply()' efter deklarationen av 'int mResult'. Nu lagras resultatet av denna funktion i variabeln 'mResult' och återges i det följande. Vi använder sedan 'fånga'-funktionen och lägger till 'const char* msg' för att visa meddelandet som vi skrev i avsnittet 'kasta'.
Kod 4:
#includeanvänder sig av namnutrymme std ;
dubbel multiplicera ( int nummer 1 , int nummer 2 ) {
om ( nummer 2 <= 0 ) {
kasta 'Vi multiplicerar inte värdet med noll eller negativt värde!' ;
}
lämna tillbaka ( nummer 1 * nummer 2 ) ;
}
int huvud ( ) {
int nyttNum1 = 3. 4 ;
int nyttNum2 = 12 ;
int mResultat ;
Prova {
mResultat = multiplicera ( nyttNum1, nyttNum2 ) ;
cout << 'Resultatet av multiplikation är' << mResultat << endl ;
}
fånga ( konst röding * medd ) {
cerr << medd << endl ;
}
lämna tillbaka 0 ;
}
Produktion:
Värdet som vi lägger till är '12' som vi lägger till villkoret på. Så, 'multiply()'-funktionen utförs eftersom villkoret inte är sant. Resultatet av multiplikationen visas. 'Försök'-delen exekveras här.
Slutsats
'Try-catch'-konceptet och koderna i denna guide studeras i detalj. Vi undersökte detta 'prova-fånga'-koncept grundligt och visade hur det fungerar i C++-programmering. Vi definierade att termen 'kastning' skapar ett undantag när ett fel hittas som låter oss skriva vår unika kod. Med hjälp av 'catch'-uttrycket kan vi specificera ett kodblock som ska köras om ett undantag dyker upp i 'try'-delen.