C++ Undtagelseshåndtering: Prøv, fang, kast Eksempel

Hvis der opstår en usædvanlig situation inden for denne kodesektion, vil der blive givet en undtagelse. Dernæst vil undtagelsesbehandleren overtage kontrollen over programmet.

I tilfælde af at der ikke opstår en usædvanlig omstændighed, vil koden køre normalt. Behandlerne vil blive ignoreret.

I denne C++ tutorial, vil du lære:

Hvorfor undtagelseshåndtering?

Her er grunden til at bruge Exception Handling i C++:

• Du vil adskille din fejlhåndteringskode fra din normale kode. Koden bliver mere læsbar og nemmere 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, vil håndtere de ufangede undtagelser.

Nøgleord til håndtering af undtagelser

Undtagelseshåndtering i C++ drejer sig om disse tre nøgleord:

• kaste– når et program støder på et problem, giver det en undtagelse. Kast nøgleordet hjælper programmet med at udføre kastet.
• fangst– et program bruger en undtagelsesbehandler til at fange en undtagelse. Det føjes til den del af et program, hvor du skal håndtere problemet. Det gøres ved at bruge søgeordet catch.
• prøv– prøveblokken identificerer den kodeblok, for hvilken visse undtagelser vil blive aktiveret. Den skal efterfølges af en/flere fangblokke.

Antag, at en kodeblok vil rejse en undtagelse. Undtagelsen vil blive fanget af en metode, der bruger try and catch søgeord. Prøv/fang-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 prøvesætning, kan vi have mange catch-sætninger.
• ExceptionName er navnet på den undtagelse, der skal fanges.
• Undtagelse1, undtagelse2 og undtagelseN er dine definerede navne for at henvise til undtagelserne.

Eksempel 1:

#include<iostream>
#include<vector>
using namespace std;

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

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluder iostream-headerfilen i programmet for at bruge dens funktioner.
2. Inkluder vektorheader-filen i programmet for at bruge dets funktioner.
3. Inkluder std-navneområdet i programmet til dets klasser uden at kalde det.
4. Kald funktionen main(). Programlogikken skal tilføjes i dens krop.
5. Opret en vektor ved navn vec for at gemme heltalsdata.
6. Tilføj elementet 0 til vektoren kaldet vec.
7. Tilføj elementet 1 til vektoren kaldet vec.
8. En kommentar. Det vil blive sprunget over af C++ compiler.
9. Brug try-sætningen til at fange en undtagelse. { markerer begyndelsen af ​​brødteksten i try/catch-blokken. Koden tilføjet i brødteksten bliver den beskyttede kode.
10. Prøv at få adgang til elementet, der er gemt ved indeks 2 (tredje element) af vektoren ved navn vec. Dette element eksisterer ikke.
11. Slutningen af ​​brødteksten af ​​try/catch-blokken.
12. Fang undtagelsen. Den returnerede fejlmeddelelse vil blive gemt i variablen f.eks.
13. Udskriv en besked på konsollen, hvis undtagelsen er fanget.
14. Enden af ​​fangblokkens krop.
15. Programmet bør returnere en værdi ved vellykket udførelse.
16. Slutningen af ​​hoved() funktionsteksten.

Eksempel 2:

#include <iostream>
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;
}

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluder iostream-headerfilen i programmet for at bruge dets 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 heltalsargumenter, x og y. Funktionen skulle returnere et dobbelt resultat.
4. Brug en if-sætning til at kontrollere, om værdien af ​​variabelargumentet y er 0. { markerer begyndelsen af ​​if-legemet.
5. Beskeden, der skal returneres/smides, hvis y er 0.
6. Slutningen af ​​brødteksten i if-erklæringen.
7. ZeroDivision-funktionen skal returnere værdien af ​​x/y.
8. Slut på brødteksten af ​​funktionen zeroDivision.
9. Kald main() metoden. { markerer begyndelsen af ​​denne metode.
10. Deklarer 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 try-sætningen til at fange en undtagelse. { markerer begyndelsen af ​​brødteksten i try/catch-blokken. Koden tilføjet i brødteksten bliver den beskyttede kode.
14. Kald nulopdelingsfunktionen og gå videre til argumenterne a og b, det vil sige 11 og 0. Resultatet af denne operation vil blive gemt i variabel c.
15. Udskriv værdien af ​​variabel c på konsollen.
16. Slutningen af ​​brødteksten af ​​try/catch-blokken.
17. Fang undtagelsen. Den returnerede fejlmeddelelse vil blive gemt i den variable meddelelse.
18. Udskriv den returnerede fejlmeddelelse på konsollen.
19. Enden af ​​fangblokkens krop.
20. Programmet bør returnere en værdi ved vellykket udførelse.
21. Slutningen af ​​hoved() funktionsteksten.

C++ Standard undtagelser

C++ leveres med en liste over standard undtagelser defineret i klasse. Disse er beskrevet nedenfor:

undtagelse	Description
std::undtagelse	Dette er en undtagelse og overordnet klasse af alle standard C++ undtagelser.
std::bad_alloc	Denne undtagelse er smidt af et nyt søgeord.
std::bad_cast	Dette er en undtagelse kastet af dynamic_cast.
std::dårlig_undtagelse	En nyttig enhed til at håndtere 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::domæne_fejl	Dette er en undtagelse, der er smidt efter brug af et matematisk ugyldigt domæne.
std::ugyldigt_argument	En undtagelse for at bruge ugyldige argumenter.
std::længde_fejl	En undtagelse kastet efter oprettelse af en stor std::streng.
std::out_of_range	Kastet af ved metode.
std::runtime_error	Dette er en undtagelse, som ikke kan opdages ved at læse koden.
std::overflow_error	Denne undtagelse er smidt efter forekomsten af ​​et matematisk overløb.
std::range_error	Denne undtagelse opstår, når du forsøger at gemme en værdi uden for området.
std::underflow_error	En undtagelse kastet efter forekomsten af ​​matematisk underløb.

Brugerdefinerede undtagelser

C++ std::exception class giver os mulighed for at definere objekter, der kan kastes som undtagelser. Denne klasse er blevet defineret i overskrift. Klassen giver os en virtuel medlemsfunktion ved navn hvad.

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

Eksempel:

#include <iostream>
#include <exception>
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;	
}

Output:

Her er et skærmbillede af koden:

Kodeforklaring:

1. Inkluder iostream-header-filen i vores program. Vi vil bruge dens funktioner uden at få fejl.
2. Inkluder undtagelseshovedfilen i vores program. Vi vil bruge dens 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 af C++.
5. Begyndelsen af ​​klassens krop.
6. Overskriv den virtuelle medlemsfunktion what() defineret i undtagelsesheader-filen. Vi vil derefter beskrive vores egen undtagelse, den nye undtagelse.
7. Start definitionen af ​​den nye undtagelse.
8. Den besked, der skal returneres, hvis den nye undtagelse fanges.
9. Slut på definitionen af ​​den nye undtagelse.
10. Slutningen af ​​brødteksten i klassen newException. The newex er navnet, der skal bruges til at fange vores nye undtagelse, hvorefter den newException vil blive kaldt.
11. Kald funktionen main(). Programlogikken skal tilføjes i dens krop. { markerer begyndelsen af ​​dens krop.
12. Brug en try-sætning til at markere koden, inden for hvilken vi skal markere undtagelsen. { markerer begyndelsen af ​​brødteksten i try/catch-blokken. Koden omgivet af dette vil blive beskyttet.
13. Smid newex-undtagelsen, hvis den bliver fanget.
14. Slut på prøvekroppen.
15. Brug catch-sætningen til at fange undtagelsen. Undtagelsesfejlmeddelelsen vil blive gemt i variabel ex.
16. Udskriv undtagelsesfejlmeddelelsen på konsollen.
17. Slutningen af ​​fangstteksten.
18. Programmet bør returnere en værdi, hvis det udføres med succes.
19. Slutningen af ​​hoveddelen af ​​funktionen main().

Resumé

• Med undtagelseshåndtering i C++, kan du håndtere runtime fejl.
• Kørselsfejl er de fejl, der opstår under programafvikling.
• Undtagelseshåndtering hjælper dig med at håndtere eventuelle uventede omstændigheder i dit program.
• Når den uventede omstændighed indtræffer, overføres programstyringen til behandlere.
• For at fange en undtagelse placerer du en kodesektion under try-catch-blokken.
• Nøgleordet throw hjælper programmet med at kaste undtagelser, hvilket hjælper programmet med at håndtere problemet.
• Nøgleordet try hjælper med at identificere den kodeblok, for hvilken visse undtagelser vil blive aktiveret.
• Vi kan overskrive what()-funktionen i undtagelsesheader-filen for at definere vores undtagelser.