Question

I have a base and a derived exceptions, public inner classes of store:

//base class - ProductException
    class ProductException: exception
    {
    protected:
        const int prodNum;
    public:
        //default+input constructor
        ProductException(const int& inputNum=0);
        //destructor
        ~ProductException();
        virtual const char* what() const throw();
    };

    //derived class - AddProdException
    class AddProdException: ProductException
    {
    public:
        //default+input constructor
        AddProdException(const int& inputNum=0);
        //destructor
        ~AddProdException();
        //override base exception's method
        virtual const char* what() const throw();
    };

this function which throws the derived exception:

void addProduct(const int& num,const string& name) throw(AddProdException);
void Store::addProduct( const int& num,const string& name )
{
    //irrelevant code...
    throw(AddProdException(num));
}

and a function which calls the function and tries to catch an exception:

try
{
    switch(op)
    {
        case 1:
        {
            cin>>num>>name;
            st.addProduct(num,name);
            break;
        }
    }
}
...
catch(Store::ProductException& e)
{
    const char* errStr=e.what();
    cout<<errStr;
    delete[] errStr;
}

The derived class should get caught, but I keep getting the error “unhandled exception”. Any ideas why? Thanks!

Answer 1

The reason is that AddProdException is not a ProductException, because you are using private inheritance:

class AddProdException: ProductException {};

You need to use public inheritance:

class AddProdException: public ProductException {};

The same applies to ProductException and exception, assuming the latter is an std::exception.