Exception Handling in C++ | What is Exception Handling in C++

Exception dealing with in C++ is a particular situation for builders to deal with. In programming, it’s regular to commit errors that immediate uncommon circumstances known as errors. All in all, these errors are of three varieties:

1. Syntax Error
2. Logical Error 
3. Runtime Error

What is Exception Handling in C++? 

Exception Handling in C++ is outlined as a technique that takes care of a shocking situation like runtime errors. At no matter level a sudden scenario occurs, there’s a motion of this system management to a novel operate often called Handlers. 

To catch the exceptions, you place some code phase beneath particular case investigation and that’s stored inside a” try-catch ” block.

When an unusual circumstance occurs inside that a part of the code, an exception will probably be thrown. Then, the exception handler will take management of this system. 

When no exception situation occurs, the code will execute ordinarily. The handlers will probably be disregarded.

A easy instance to grasp Exceptional dealing with in C++

#embrace <iostream>

int major() {
    attempt {
        // Code which will throw an exception
        int numerator = 10;
        int denominator = 0;
        int end result = numerator / denominator;

        std::cout << "Result: " << end result << std::endl;
    }
    catch (const std::exception& e) {
        std::cout << "Exception occurred: " << e.what() << std::endl;
    }

    return 0;
}

In this instance, the division operation numerator/denominator might throw a std::exception when the denominator is zero. The attempt block comprises the code which may throw an exception, and the catch block catches the exception and handles it appropriately.

Also, now you may study Exception Handling in C – A Free Online Course in Hindi

Why Exception Handling? 

Here are the explanation why Exception Handling is utilized in C++:

• You will isolate your error dealing with code out of your strange code. The code will probably be extra coherent and easier to maintain up with. 
• Functions can cope with the Exception they choose. Regardless of whether or not a operate throws quite a few exceptions, it can simply cope with a number of. The caller will cope with the uncaught exceptions. 

Basic Keywords in Exception Handling: 

Exception Handling in C++ falls round these three key phrases: 

What is attempt throw catch in c++?

Try throw catch in c++ is outlined as:

• Throw – when a program experiences a difficulty, it throws an Exception. The throw key phrase assists this system by performing a throw. 
• Catch – a program that utilises an exception handler to catch an Exception. It is added to the a part of a program the place it’s essential to cope with the error.
• Try – the attempt block recognises the code block for which sure exceptions will probably be enacted. It should be adopted by one/extra catch blocks. 

How try-catch in c++ works?

In C++, exception dealing with is finished utilizing the try-catch mechanism. It permits you to catch and deal with exceptions that happen in the course of the execution of your program. The attempt block comprises the code which may throw an exception, and it handles the exception if it happens. Here’s the way it works:

1. The code which may throw an exception is enclosed inside a attempt block. If an exception happens inside this block, the execution of the code throughout the attempt block is straight away stopped, and this system appears for an identical catch block to deal with the exception.
2. After an exception is thrown, this system searches for an identical catch block. An identical catch block is one that may deal with the particular sort of exception that was thrown. If an identical catch block is discovered, the code inside that block is executed.
3. If no matching catch block is discovered throughout the present scope, this system strikes up the decision stack, trying to find an applicable catch block within the calling features. This course of continues till an identical catch block is discovered or till this system reaches the highest stage of this system (i.e., major() operate).
4. Once an identical catch block is discovered, the code inside that block is executed, and this system continues executing from the purpose instantly after the try-catch block.

Here’s an instance as an instance the utilization of try-catch:

#embrace <iostream>

int major() {
    attempt {
        // Code which may throw an exception
        int num1, num2;
        std::cout << "Enter two numbers: ";
        std::cin >> num1 >> num2;

        if (num2 == 0) {
            throw std::runtime_error("Divide by zero exception");
        }

        int end result = num1 / num2;
        std::cout << "Result: " << end result << std::endl;
    }
    catch (const std::exception& e) {
        // Exception dealing with code
        std::cout << "Exception caught: " << e.what() << std::endl;
    }

    return 0;
}

Example1: Multiple Code Block

#embrace <iostream>

int major() {
    attempt {
        // Code which will throw an exception
        int numerator = 10;
        int denominator = 0;
        int end result = numerator / denominator;

        std::cout << "Result: " << end result << std::endl;
    }
    catch (const std::runtime_error& e) {
        std::cout << "Runtime error occurred: " << e.what() << std::endl;
    }
    catch (const std::exception& e) {
        std::cout << "Exception occurred: " << e.what() << std::endl;
    }

    return 0;
}

Here, now we have added an extra catch block to deal with a particular sort of exception, std::runtime_error, earlier than catching the extra common std::exception. The particular exception sorts needs to be caught earlier than the extra common ones.

Example2: Throwing a Custom Exception

#embrace <iostream>
#embrace <stdexcept>

void examineAge(int age) {
    if (age < 0) {
        throw std::invalid_argument("Age can't be destructive.");
    }
    else if (age < 18) {
        throw std::out_of_range("You should be no less than 18 years previous.");
    }
    else {
        std::cout << "Access granted." << std::endl;
    }
}

int major() {
    attempt {
        int personAge = 15;
        examineAge(personAge);
    }
    catch (const std::exception& e) {
        std::cout << "Exception occurred: " << e.what() << std::endl;
    }

    return 0;
}

In this instance, the examineAge the operate throws customized exceptions, std::invalid_argument and std::out_of_range, primarily based on the age worth offered. The attempt block calls the examineAge operate, and if an exception is thrown, it’s caught and dealt with within the catch block.

How to make use of try-catch in c++?

Try-catch is a vital key phrase whereas performing distinctive circumstances.
In the Try block, the “throw” key phrase throws an exception when the code detects an issue, which lets us create a customized error.
Now “catch” key phrase comes into an image i.e. “catch” key phrase permits you to outline a block of code to be executed if an error happens within the attempt block.

How do you catch exceptions in C++?

To catch exceptions, part of the code is stored beneath inspection. This is finished by closing that a part of the code in a try-block. When an distinctive circumstance arises inside that block, an exception is thrown and an exception handler takes management over this system.

How to throw an exception in c++?

Exception in c++ is thrown through the use of the “throw” key phrase from contained in the try-block. Exception handlers are declared with the “catch” key phrase and should be positioned instantly after the “try” block.

C++ Standard Exceptions

What is C++ Standard Exceptions?

C++ customary exceptions present an inventory of normal exceptions outlined in <exception> which we are able to use in our applications.
These exceptions are organized in a parent-child class hierarchy:

User-Defined Exceptions 

The C++ std::exception class permits us to outline objects that may be thrown as exceptions. This class is outlined within the <exception> header. The class provides us a digital member operate named what. 

This operate returns an invalid ended character sequence of sort char*. We can overwrite it in decided courses to have an exception depiction.

This brings us to the tip of the weblog on Exception Handling in C++. Hope this lets you up-skill your C++ expertise. To study extra about programming and different associated ideas, take a look at the programs on Great Learning Academy. 

Also, in case you are making ready for Interviews, take a look at these Interview Questions for C++ to ace it like a professional

Seize the alternatives that await you thru our dynamic vary of free programs. Whether you’re interested by Cybersecurity, Management, Cloud Computing, IT, or Software, we provide a broad spectrum of industry-specific domains. Gain the important expertise and experience to thrive in your chosen area and unleash your full potential.