Custom Exception Class - Why do we need it?

Question

I was reading about custom exception.. This is what I did.

#include <iostream>
#include <exception>
#include <stdexcept>

using namespace std;

class myBase : public exception
{
public:
    myBase() {};
    virtual ~myBase(void) {};
    virtual const char* what() const { return "Hello, you have done a mistake"; }
};

class myDerived : public myBase
{
public:
    myDerived() {};
    virtual ~myDerived(void) {};
    const char* what() const { return "Hello, you have done a mistake in - derived class"; }
};

int main(void)
{
    try
    {
        throw myDerived();
    }
    catch (exception& e)
    {
        cout << e.what() << endl;
    }

    getchar();
    return 0;
}

I understood that, I can throw my custom class objects and can catch it. I don't understand the purpose of this. Can someone explain me why do we need custom exception class? Any practical examples will help me understanding the purpose of using custom exception classes.

Thanks.

What if another user defined `class` inherits (e.g., `class myDerived2`) from `exception` and throws, your `catch` can't distinguish between the two exceptions. — 101010, Jun 17 '14 at 09:11

score 1 · Answer 1 · answered Jun 17 '14 at 09:22

in c++ you can throw any type you want, you don't need to inherit from std::exception. the ability to catch different types in different catch statement is useful because you can throw different exception types for different conditions. In this way you can properly handle different exeptional cases.

in this toy example, based on the variable one a different exception is thrown and handled in the catch statements. In this case, "string" is printed to stdout.

#include <iostream>

using namespace std;

int main(void)
{
    int one = 0;
    try
    {
        if(one)
            throw 1;
        else
            throw "string";
    }
    catch (int& i)
    {
        cout << i << endl;
    }
    catch (const char* s)
    {
        cout << s << endl;
    }

    return 0;
}

101010 · Accepted Answer · 2014-06-17T09:37:02.997

Lets say that there's also another user defined class that also inherits from class myBase:

class myDerived2 : public myBase {
public:
    myDerived2() {}
    virtual ~myDerived2() {}
};

and lets say that you have a try catch clause:

try {
  myDerived  A;
  myDerived2 B;
  ...
  /* to staff with both A and B */
  ...
} catch (std::exception& e){
  cout << e.what() << endl; 
}

In the above try - catch clause you restrict your self by treating exceptions of type myDerived and myDerived2 in identical way.
What if you wanted to treat throws of type myDerived and myDerived2 in a different way?
Then you would have to define a different try-catch clause:

try {
  myDerived  A;
  myDerived2 B;
  ...
  /* to staff with both A and B */
  ...
} catch (myDerived &d1) {
  /* treat exception of type myDerived */
} catch (myDerived &d2) {
  /* treat exception of type myDerived2 */
}

From the above example I think it's clear that defining custom exceptions gives the programmer a valuable and versatile tool for dealing with throws in a more versatile and specialized manner.

First thanks for the reply. My question is, I throw my class object and i can catch it in the catch block. Why to create a class for that? Any use of creating custom class for exceptions? what sort of power I get if i create custom class? — NJMR, Jun 17 '14 at 10:12
I think it's clear from the example that by creating custom exceptions you have the opportunity to catch and treat them separately (i.e., in a specialized manner). That is, in your case you catch all exceptions of type `std::exception` and treat them in the same manner no matter if the actual object is `myDerived` or some other object that also inherits from `std::exception`. — 101010, Jun 17 '14 at 10:46

Custom Exception Class - Why do we need it?

2 Answers2