C ++ Undtagelseshåndtering: Prøv, fangst, kast eksempel

Indholdsfortegnelse:

Anonim

Hvad er undtagelseshåndtering i C ++?

Undtagelseshåndtering i C ++ giver dig en måde at håndtere uventede omstændigheder som runtime-fejl på. Så når der opstår en uventet omstændighed, overføres programstyringen til specielle funktioner kendt som handlers.

For at fange undtagelserne placerer du en del af koden under inspektion af undtagelser. Kodeafsnittet er placeret i forsøge-blokken.

Hvis der opstår en ekstraordinær situation inden for dette afsnit af koden, kastes en undtagelse. Dernæst overtager undtagelsesbehandleren kontrollen med programmet.

Hvis der ikke opstår ekstraordinære omstændigheder, udføres koden normalt. Handlerne ignoreres.

I denne C ++ tutorial lærer du:

  • Hvad er undtagelseshåndtering i C ++?
  • Hvorfor håndtering af undtagelser?
  • Undtagelse Håndtering af nøgleord
  • Syntaks:
  • C ++ standardundtagelser
  • Brugerdefinerede undtagelser

Hvorfor håndtering af undtagelser?

Her er årsagen til brug af Exception Handling i C ++:

  • Du adskiller din fejlhåndteringskode fra din normale kode. Koden vil være mere læselig og lettere at vedligeholde.
  • Funktioner kan håndtere de undtagelser, de vælger. Selvom en funktion kaster mange undtagelser, vil den kun håndtere nogle. Den, der ringer op, håndterer de ikke fangede undtagelser.

Undtagelse Håndtering af nøgleord

Undtagelsesbehandling i C ++ drejer sig om disse tre nøgleord:

  • kast - når et program støder på et problem, kaster det en undtagelse. Kast nøgleordet hjælper programmet med at udføre kastet.
  • fange - et program bruger en undtagelsesbehandler til at fange en undtagelse. Det føjes til det afsnit af et program, hvor du skal håndtere problemet. Det gøres ved hjælp af fangst nøgleordet.
  • prøv - prøveblokken identificerer kodeblokken, som visse undtagelser vil blive aktiveret for. Det skal følges af en / flere fangstblokke.

Antag at en kodeblok giver en undtagelse. Undtagelsen fanges ved en metode, der bruger søgeord til at prøve og fange. Try / catch-blokken skal omgive kode, der kan give en undtagelse. En sådan kode er kendt som beskyttet kode.

Syntaks:

Try / catch tager denne syntaks:

try {// the protected code} catch( Exception_Name exception1 ) {// catch block} catch( Exception_Name exception2 ) {// catch block} catch( Exception_Name exceptionN ) {// catch block}
  • Selvom vi har en forsøgserklæring, kan vi have mange fangstudsagn.
  • ExceptionName er navnet på den undtagelse, der skal fanges.
  • Undtagelsen1, undtagelse2 og undtagelseN er dine definerede navne til henvisning til undtagelserne.

Eksempel 1:

#include#includeusing namespace std;int main() {vector vec;vec.push_back(0);vec.push_back(1);// access the third element, which doesn't existtry{vec.at(2);}catch (exception& ex){cout << "Exception occurred!" << endl;}return 0;}

Produktion:

Her er et screenshot af koden:

Kode Forklaring:

  1. Inkluder iostream headerfilen i programmet for at bruge dens funktioner.
  2. Inkluder vektorhovedfilen i programmet for at bruge dens funktioner.
  3. Inkluder std navneområdet i programmet til dets klasser uden at kalde det.
  4. Ring til hovedfunktionen (). Programmets logik skal tilføjes i dets krop.
  5. Opret en vektor med navnet vec til at gemme heltalsdata.
  6. Føj elementet 0 til vektoren med navnet vec.
  7. Føj element 1 til vektoren med navnet vec.
  8. En kommentar. Det springes over af C ++ - kompilatoren.
  9. Brug prøveerklæringen til at få en undtagelse. {Markerer begyndelsen på kroppen af ​​prøve / fangstblok. Koden tilføjet i kroppen bliver den beskyttede kode.
  10. Prøv at få adgang til det element, der er gemt i indeks 2 (tredje element) af vektoren med navnet vec. Dette element findes ikke.
  11. Slutningen af ​​prøven / fangstblokken.
  12. Fang undtagelsen. Den returnerede fejlmeddelelse gemmes i variablen ex.
  13. Udskriv en meddelelse på konsollen, hvis undtagelsen er fanget.
  14. Enden på kroppen af ​​fangstblokken.
  15. Programmet skal returnere en værdi efter vellykket udførelse.
  16. Slutningen af ​​hovedfunktionsorganet ().

Eksempel 2:

#include using namespace std;double zeroDivision(int x, int y) {if (y == 0) {throw "Division by Zero!";}return (x / y);}int main() {int a = 11;int b = 0;double c = 0;try {c = zeroDivision(a, b);cout << c << endl;}catch (const char* message) {cerr << message << endl;}return 0;}

Produktion:

Her er et screenshot af koden:

Kode Forklaring:

  1. Inkluder iostream headerfilen i programmet for at bruge dens funktioner.
  2. Inkluder std navneområdet i programmet til dets klasser uden at kalde det.
  3. Opret en funktion med navnet zeroDivision, der tager to heltalargumenter, x og y. Funktionen skal returnere et dobbelt resultat.
  4. Brug en if-sætning til at kontrollere, om værdien af ​​variabelargumentet y er 0. {markerer begyndelsen på if-kroppen.
  5. Beskeden, der skal returneres / kastes, hvis y er 0.
  6. Slutningen af ​​if-erklæringen.
  7. ZeroDivision-funktionen skal returnere værdien af ​​x / y.
  8. Slutningen af ​​zeroDivision-funktionen.
  9. Ring til hovedmetoden (). {Markerer starten på denne metode.
  10. Erklær en heltalsvariabel, og tildel den værdien 11.
  11. Erklær en heltalsvariabel b og tildel den værdien 0.
  12. Erklær en dobbelt variabel c og tildel den værdien 0.
  13. Brug prøveerklæringen til at få en undtagelse. {Markerer begyndelsen på kroppen af ​​prøve / fangstblok. Koden tilføjet i kroppen bliver den beskyttede kode.
  14. Kald funktionen zeroDivision og videregiv til argumenterne a og b, dvs. 11 og 0. Resultatet af denne operation gemmes i variabel c.
  15. Udskriv værdien af ​​variabel c på konsollen.
  16. Slutningen af ​​prøven / fangstblokken.
  17. Fang undtagelsen. Den returnerede fejlmeddelelse gemmes i den variable meddelelse.
  18. Udskriv den returnerede fejlmeddelelse på konsollen.
  19. Enden på kroppen af ​​fangstblokken.
  20. Programmet skal returnere en værdi efter vellykket udførelse.
  21. Slutningen af ​​hovedfunktionsorganet ().

C ++ standardundtagelser

C ++ kommer med en liste over standardundtagelser defineret i klassen . Disse er beskrevet nedenfor:

Undtagelse Beskrivelse
std :: undtagelse Dette er en undtagelse og overordnet klasse for alle standard C ++ undtagelser.
std :: bad_alloc Denne undtagelse skyldes et nyt søgeord.
std :: bad_cast Dette er en undtagelse fra dynamic_cast.
std :: dårlig_undtagelse En nyttig enhed til håndtering af uventede undtagelser i C ++ - programmer.
std :: bad_typeid En undtagelse kastet af typeid.
std :: logic_error Denne undtagelse kan teoretisk detekteres ved at læse kode.
std :: domain_error Dette er en undtagelse, der kastes efter brug af et matematisk ugyldigt domæne.
std :: ugyldigt_argument En undtagelse kastet for at bruge ugyldige argumenter.
std :: længde_fejl En undtagelse kastet efter oprettelse af en stor std :: streng.
std :: out_of_range Kastes ved metode.
std :: runtime_error Dette er en undtagelse, der ikke kan detekteres ved læsning af koden.
std :: overflow_error Denne undtagelse kastes efter forekomsten af ​​et matematisk overløb.
std :: range_error Denne undtagelse kastes, når du forsøger at gemme en værdi uden for området.
std :: underflow_error En undtagelse kastet efter forekomsten af ​​matematisk understrømning.

Brugerdefinerede undtagelser

C ++ std :: undtagelsesklassen giver os mulighed for at definere objekter, der kan kastes som undtagelser. Denne klasse er defineret i headeren . Klassen giver os en virtuel medlemsfunktion med navnet what.

Denne funktion returnerer en null-afsluttet tegnsekvens af typen char *. Vi kan overskrive det i afledte klasser for at have en undtagelsesbeskrivelse.

Eksempel:

#include #include using namespace std;class newException : public exception{virtual const char* what() const throw(){return "newException occurred";}} newex;int main() {try {throw newex;}catch (exception& ex) {cout << ex.what() << '\n';}return 0;}

Produktion:

Her er et screenshot af koden:

Kode Forklaring:

  1. Inkluder iostream header-filen i vores program. Vi bruger dets funktioner uden at få fejl.
  2. Inkluder undtagelsesoverskriftsfilen i vores program. Vi bruger dets funktioner som hvad uden fejl.
  3. Inkluder std navneområdet i vores program for at bruge dets klasser uden at kalde det.
  4. Opret en ny klasse med navnet newException. Denne klasse arver undtagelsesklassen C ++.
  5. Begyndelsen på klassens krop.
  6. Overskriv den virtuelle medlemsfunktion hvad () defineret i undtagelsesoverskriftsfilen. Vi vil derefter beskrive vores egen undtagelse, den nye undtagelse.
  7. Start definitionen af ​​den nye undtagelse.
  8. Beskeden, der skal returneres, hvis den nye undtagelse er fanget.
  9. Slutningen af ​​definitionen af ​​den nye undtagelse.
  10. Slutningen af ​​kroppen af ​​klasse newException. Newex er navnet, der skal bruges til at fange vores nye undtagelse, hvorefter den nye undtagelse kaldes.
  11. Ring til hovedfunktionen (). Programmets logik skal tilføjes i dets krop. {Markerer begyndelsen på sin krop.
  12. Brug en prøveerklæring til at markere den kode, inden for hvilken vi skal markere undtagelsen. {Markerer begyndelsen på kroppen af ​​prøve / fangstblok. Koden omgivet af dette bliver beskyttet.
  13. Kast undtagelsen fra newex, hvis den er fanget.
  14. Afslutningen på prøvekroppen.
  15. Brug fangstopgørelsen til at fange undtagelsen. Undtagelsesfejlmeddelelsen gemmes i variabel ex.
  16. Udskriv undtagelsesfejlmeddelelsen på konsollen.
  17. Slutningen af ​​fangstopgørelsen.
  18. Programmet skal returnere en værdi, hvis det udføres med succes.
  19. Slutningen af ​​hovedfunktionens () krop.

Resumé:

  • Med undtagelseshåndtering i C ++ kan du håndtere runtime-fejl.
  • Kørselsfejl er de fejl, der opstår under programudførelse.
  • Undtagelsesbehandling hjælper dig med at håndtere uventede omstændigheder i dit program.
  • Når den uventede omstændighed opstår, overføres programkontrol til håndterere.
  • For at fange en undtagelse placerer du en sektion med kode under forsøge-fangstblokken.
  • Kast-nøgleordet hjælper programmet med at kaste undtagelser og hjælper programmet med at håndtere problemet.
  • Try-nøgleordet hjælper med at identificere den kodeblok, som visse undtagelser vil blive aktiveret for.
  • Vi kan overskrive hvad () -funktionen i undtagelsesoverskriftsfilen for at definere vores undtagelser.