CODEWITHSUNDEEP
c++exceptionstd
Aneesh Narayanan
Aneesh Narayanan

Reputation: 3434

usage of exception in c++

In my project codding i have to use a try catch method to find the function execution status.

   try
   {
      //sample code
      //calling functions
      function1();
      function2();
      //........
   }
   catch(//need to catch exception)
   { 
    return failure;
   }

My requirement is that i have to catch all the exceptions that thrown from the try block

i have two options here,

  1. catch(...)
  2. catch(std::exception)

I think the first one will catch all the exceptions. And the second one, std::exception is the base class for all other exception classes in my program

   class MyException : public std::exception
   {
    // All the exceptions that i have use is derived from this class
   }.

Which is better and more efficient.

Is the both method works same way. Help me and suggest any method

Upvotes: 2

Views: 159

Answers (3)

justin
justin

Reputation: 104698

In this case, you'd work your way through the types which may be thrown in the following order:

catch (MyException& e) {
  ...
}
catch (std::exception& e) {
  ...
}
catch (...) {
  ...
}

This way, you can handle the specific errors/types first, and then fall back on the weak (or untyped) handlers when the preceding handlers do not match.

Which is better and more efficient.

The order I recommended is best for handling by type. IMO, efficiency is not a concern in this scenario because correctness takes precedence and hopefully exceptions are thrown only under exceptional circumstances.

Upvotes: 4

Component 10
Component 10

Reputation: 10467

Always keep your specification as focused as possible so that you catch those that you know could be thrown, and catch derived exceptions (more specialised) before base ones:

try
{
    // Some stuff
}
catch (Derived& e)
{
    // Deal with specifics of Derived
}
catch (Base& e) 
{
    // Deal with general case of Base
}

Never use catch(...) except at the very top of your program stack (and certainly not in libraries.) When you do this, you cannot be sure about what caused the exception and therefore you cannot necessarily rely on things that you normaly would (such as memory management etc.)

Upvotes: 1

AlexTheo
AlexTheo

Reputation: 4164

I would suggest you to catch the specified exceptions only and use the catch(...) only in the main function. In my opinion the better way to use the exceptions is to implement one exception per module so each class will throw the specific exception related with the module of the class also different exceptions may be handled with a different way so I believe that

catch(const ExceptionType1& e){
}catch(const ExceptionType2& e){
}

is the better solution, also some other developer just reading this code will see which kind of exceptions could be thrown and handled....

Upvotes: 0

Related Questions