Thursday, July 25, 2024

Exception Dealing with in C++ | What’s Exception Dealing with in C++


Exception dealing with in C++ is a specific situation for builders to deal with. In programming, committing errors that immediate uncommon circumstances known as errors is regular. All in all, these errors are of three sorts:

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

What’s Exception Dealing with in C++? 

Exception dealing with in C++ is a mechanism that permits a program to cope with runtime errors and distinctive conditions in a structured and managed method. In C++, exceptions are used to deal with errors that happen throughout the execution of a program, resembling division by zero, accessing invalid reminiscence, or file I/O errors.

The fundamental thought behind exception dealing with is to separate the conventional circulate of program execution from error-handling code. As a substitute of terminating this system abruptly when an error happens, C++ gives a technique to “throw” an exception, representing the error or distinctive situation. The thrown exception is then caught by applicable “catch” blocks, the place this system can deal with the error gracefully.

Right here’s a fundamental define of how exception dealing with works in C++:

  1. Throwing an Exception:
    When a crucial error happens throughout program execution, you should use the throw assertion to boost an exception. It normally takes an object as an argument, which serves because the illustration of the error.
#embrace <iostream>

void someFunction(int worth) {
    if (worth == 0)
        throw std::runtime_error("Error: Division by zero!");
    // ... different code ...
}
  1. Catching an Exception:
    To catch an exception, you utilize a strive block. The code which may elevate an exception is positioned contained in the strive block. If an exception is thrown inside the strive block, this system will instantly leap to the corresponding catch block.
int major() {
    strive {
        int x = 10;
        int y = 0;
        someFunction(x / y);
    } catch (const std::runtime_error& e) {
        std::cout << "Exception caught: " << e.what() << std::endl;
    }
    // ... different code ...
    return 0;
}
  1. Dealing with the Exception:
    The catch block handles the caught exception. It specifies the kind of exception it may catch in parentheses, adopted by a block of code that handles the distinctive situation.
  2. A number of Catch Blocks:
    You possibly can have a number of catch blocks to deal with various kinds of exceptions. The primary catch block that matches the thrown exception’s sort might be executed, and the others might be skipped.
strive {
    // code that will throw exceptions
} catch (const SomeExceptionType& e) {
    // deal with SomeExceptionType
} catch (const AnotherExceptionType& e) {
    // deal with AnotherExceptionType
} catch (...) {
    // deal with another exception that's not caught by earlier catch blocks
}
  1. Exception Security:
    Exception security refers back to the idea of making certain {that a} program’s state stays constant even when an exception is thrown. Writing exception-safe code is important to forestall useful resource leaks and preserve knowledge integrity.

Through the use of exception dealing with, you can also make your C++ applications extra sturdy and maintainable, as they supply a technique to deal with errors in a managed method, somewhat than having this system terminate abruptly on encountering a problem.

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

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

#embrace <iostream>

int major() {
    strive {
        // Code that will throw an exception
        int numerator = 10;
        int denominator = 0;
        int outcome = numerator / denominator;

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

    return 0;
}

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

Additionally, now you’ll be able to be taught Exception Dealing with in C – A Free On-line Course in Hindi

Why Exception Dealing with? 

Exception dealing with is a vital idea in programming that permits builders to cope with sudden or distinctive conditions that will happen throughout the execution of a program. These distinctive conditions are also known as “exceptions.” Listed below are some the explanation why exception dealing with is essential:

  1. Error Administration: When a program encounters an error or sudden situation, with out exception dealing with, it’d crash or produce incorrect outcomes. Exception dealing with gives a structured technique to cope with errors and permits builders to deal with them gracefully.
  2. Robustness: Exception dealing with enhances the robustness of the software program. By catching and dealing with exceptions, builders can stop your complete program from terminating abruptly and supply customers with significant error messages, making the software program extra user-friendly.
  3. Separation of Considerations: Exception dealing with clearly separates regular program circulate and error working code. This separation makes the code simpler to learn, perceive, and preserve.
  4. Debugging: Exception dealing with aids in debugging the code. When an exception is thrown, this system can log particulars in regards to the error, which helps builders determine and repair the problem’s root trigger.
  5. Swish Restoration: In sure circumstances, applications can get well from exceptions and proceed execution as a substitute of crashing. For instance, an online server can catch an exception attributable to a client-side error and reply with an applicable HTTP error code as a substitute of shutting down.
  6. Program Stability: By dealing with exceptions appropriately, builders can be certain that this system stays steady and dependable even when going through sudden circumstances or inputs.
  7. Fail-Secure Operations: Exception dealing with is particularly essential when coping with crucial operations like file I/O, community communication, or database transactions. Dealing with exceptions accurately makes it potential to roll again transactions or carry out different vital cleanup duties to take care of knowledge integrity.
  8. Modularity: Exception dealing with permits for modular design and promotes code reusability. Features or strategies can throw exceptions, and the calling code can catch and deal with them accordingly.

Fundamental Key phrases in Exception Dealing with: 

Exception Dealing with in C++ falls round these three key phrases: 

What’s strive throw catch in c++?

In C++, strive, throw, and catch are key phrases used for exception dealing with. Exception dealing with permits builders to deal with errors or distinctive conditions gracefully and supply a structured technique to handle sudden circumstances throughout the execution of a program.

Right here’s a quick clarification of every key phrase:

  1. strive: The code which may elevate an exception is included inside the strive block. A number of catch blocks come after it. This system appears for a catch block that matches the strive block when an exception is thrown inside the strive block so as to deal with the exception.
  2. throw: To explicitly elevate or throw an exception, use the throw key phrase. Within the strive block, it’s incessantly employed when an distinctive circumstance arises. The management exits the strive block when the throw assertion is met so as to find an appropriate catch block to deal with the exception.
  3. catch: The catch block follows the strive block and is used to catch and deal with exceptions. It comprises code that executes when a selected sort of exception is thrown inside the related strive block. A number of catch blocks can be utilized for various exception varieties.
strive {
    // Code which may throw an exception
    // If an exception is thrown, management jumps to the corresponding catch block
} catch (ExceptionType1 e) {
    // Code to deal with ExceptionType1
} catch (ExceptionType2 e) {
    // Code to deal with ExceptionType2
} catch (...) {
    // Catch-all block to deal with another unhandled exceptions (elective)
}

How try-catch in c++ works?

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

  1. The code which may throw an exception is enclosed inside a strive block. If an exception happens inside this block, the execution of the code inside the strive block is instantly 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 precise 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 inside the present scope, this system strikes up the decision stack, looking for an applicable catch block within the calling capabilities. This course of continues till an identical catch block is discovered or till this system reaches the highest degree of this system (i.e., major() perform).
  4. As soon as 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.

Right here’s an instance as an example the utilization of try-catch:

#embrace <iostream>

int major() {
    strive {
        // 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 outcome = num1 / num2;
        std::cout << "Outcome: " << outcome << std::endl;
    }
    catch (const std::exception& e) {
        // Exception dealing with code
        std::cout << "Exception caught: " << e.what() << std::endl;
    }

    return 0;
}

Example1: A number of Code Block

#embrace <iostream>

int major() {
    strive {
        // Code that will throw an exception
        int numerator = 10;
        int denominator = 0;
        int outcome = numerator / denominator;

        std::cout << "Outcome: " << outcome << 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;
}

Right here, we now have added an extra catch block to deal with a selected sort of exception, std::runtime_error, earlier than catching the extra common std::exception. The particular exception varieties must be caught earlier than the extra common ones.

Example2: Throwing a Customized Exception

#embrace <iostream>
#embrace <stdexcept>

void checkAge(int age) {
    if (age < 0) {
        throw std::invalid_argument("Age can't be unfavorable.");
    }
    else if (age < 18) {
        throw std::out_of_range("You should be a minimum of 18 years previous.");
    }
    else {
        std::cout << "Entry granted." << std::endl;
    }
}

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

    return 0;
}

On this instance, the checkAge the perform throws customized exceptions, std::invalid_argument and std::out_of_range, based mostly on the age worth supplied. The strive block calls the checkAge perform, and if an exception is thrown, it’s caught and dealt with within the catch block.

Tips on how to use try-catch in c++?

Strive-catch is a crucial key phrase whereas performing distinctive circumstances.
Within the Strive 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 strive block.

How do you catch exceptions in C++?

To catch exceptions, part of the code is saved underneath inspection. That is carried out 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.

Tips on how to throw an exception in c++?

In C++, you’ll be able to throw an exception utilizing the throw key phrase. Exceptions are a technique to deal with error circumstances or distinctive conditions in your code that will disrupt the conventional circulate of execution. When an exception is thrown, this system will cease executing the present block of code and begin looking for an applicable exception handler (catch block) to deal with the exception.

To throw an exception in C++, you usually observe these steps:

Outline a customized exception class (elective):
You possibly can create your personal customized exception class by inheriting from the usual std::exception class or any of its derived lessons. This step is elective, as you too can use the usual exception lessons supplied by the C++ Normal Library.

Throw the exception:
Use the throw key phrase adopted by the exception object you wish to throw. When you have created a customized exception class, you’ll be able to instantiate an object of that class and move it to the throw assertion.

Catch the exception (elective):
To deal with the thrown exception, that you must enclose the code that will throw an exception inside a try-catch block. The catch block will catch the thrown exception and will let you deal with it gracefully.

Right here’s an instance of how one can throw and catch an exception in C++:

#embrace <iostream>

// Customized exception class (elective)
class MyException : public std::exception {
public:
    digital const char* what() const noexcept override {
        return "My customized exception occurred!";
    }
};

int major() {
    strive {
        int age;
        std::cout << "Enter your age: ";
        std::cin >> age;

        if (age < 0) {
            // Throw a customized exception
            throw MyException();
        }

        // Different code that will throw exceptions
        // ...

    } catch (const MyException& ex) {
        std::cout << "Caught customized exception: " << ex.what() << std::endl;
    } catch (const std::exception& ex) {
        // Catch different exceptions derived from std::exception
        std::cout << "Caught normal exception: " << ex.what() << std::endl;
    } catch (...) {
        // Catch another unhandled exceptions (not advisable, however could be helpful for debugging)
        std::cout << "Caught unknown exception." << std::endl;
    }

    return 0;
}

On this instance, if the person enters a unfavorable age, the MyException object might be thrown, and it is going to be caught by the corresponding catch block.

C++ Normal Exceptions

In C++, you’ll be able to create your personal user-defined exceptions to deal with particular error circumstances in your code. Consumer-defined exceptions will let you outline customized exception varieties that inherit from the usual C++ std::exception class or any of its derived lessons. This lets you throw and catch particular exception varieties that symbolize totally different error conditions.

Right here’s a step-by-step information on how one can outline and use user-defined exceptions in C++:

Step 1: Outline your customized exception class

#embrace <exception>
#embrace <string>

class MyException : public std::exception {
public:
    MyException(const std::string& message) : message_(message) {}

    // Override the what() methodology to supply error description
    const char* what() const noexcept override {
        return message_.c_str();
    }

personal:
    std::string message_;
};

Step 2: Throw the user-defined exception
You possibly can throw the customized exception in your code when a selected error situation is encountered. For instance:

#embrace <iostream>

double divideNumbers(double numerator, double denominator) {
    if (denominator == 0) {
        throw MyException("Division by zero shouldn't be allowed.");
    }
    return numerator / denominator;
}

int major() {
    strive {
        double outcome = divideNumbers(10.0, 0.0);
        std::cout << "Outcome: " << outcome << std::endl;
    } catch (const MyException& ex) {
        std::cout << "Error: " << ex.what() << std::endl;
    }

    return 0;
}

On this instance, we outlined a customized MyException class and used it to throw an exception when dividing by zero within the divideNumbers perform. Within the major perform, we catch the exception and deal with it by printing the error message.

Step 3: Deal with the user-defined exception
When an exception is thrown, you’ll be able to catch it utilizing a strive block and deal with it with a corresponding catch block. On this instance, we catch MyException and print its error message utilizing the what() methodology.

Consumer-defined exceptions are useful for offering significant error messages and dealing with particular error eventualities in your code. You possibly can create a number of customized exception lessons to symbolize various kinds of errors, which permits for higher group and readability in your exception dealing with.

What’s C++ Normal Exceptions?

C++ normal exceptions present a listing 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:

Consumer-Outlined Exceptions 

In C++, you’ll be able to create your personal user-defined exceptions to deal with particular error circumstances in your code. Consumer-defined exceptions will let you outline customized exception varieties that inherit from the usual C++ std::exception class or any of its derived lessons. This lets you throw and catch particular exception varieties that symbolize totally different error conditions.

Right here’s a step-by-step information on how one can outline and use user-defined exceptions in C++:

Step 1: Outline your customized exception class

#embrace <exception>
#embrace <string>

class MyException : public std::exception {
public:
    MyException(const std::string& message) : message_(message) {}

    // Override the what() methodology to supply error description
    const char* what() const noexcept override {
        return message_.c_str();
    }

personal:
    std::string message_;
};

Step 2: Throw the user-defined exception
You possibly can throw the customized exception in your code when encountering a selected error situation. For instance:

#embrace <iostream>

double divideNumbers(double numerator, double denominator) {
    if (denominator == 0) {
        throw MyException("Division by zero shouldn't be allowed.");
    }
    return numerator / denominator;
}

int major() {
    strive {
        double outcome = divideNumbers(10.0, 0.0);
        std::cout << "Outcome: " << outcome << std::endl;
    } catch (const MyException& ex) {
        std::cout << "Error: " << ex.what() << std::endl;
    }

    return 0;
}

On this instance, we outlined a customized MyException class and used it to throw an exception when dividing by zero within the divideNumbers perform. Within the major perform, we catch the exception and deal with it by printing the error message.

Step 3: Deal with the user-defined exception
When an exception is thrown, you’ll be able to catch it utilizing a strive block and deal with it with a corresponding catch block. On this instance, we catch MyException and print its error message utilizing the what() methodology.

Consumer-defined exceptions are useful for offering significant error messages and dealing with particular error eventualities in your code. You possibly can create a number of customized exception lessons to symbolize various kinds of errors, which permits for higher group and readability in your exception dealing with.

This brings us to the tip of the weblog on Exception Dealing with in C++. Hope this lets you up-skill your C++ abilities. To be taught extra about programming and different associated ideas, try the programs on Nice Studying Academy

Additionally, in case you are making ready for Interviews, try 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 or not you’re all for Cybersecurity, Administration, Cloud Computing, IT, or Software program, we provide a broad spectrum of industry-specific domains. Achieve the important abilities and experience to thrive in your chosen area and unleash your full potential.

Related Articles

LEAVE A REPLY

Please enter your comment!
Please enter your name here

Stay Connected

0FansLike
3,912FollowersFollow
0SubscribersSubscribe
- Advertisement -spot_img

Latest Articles