使用时 <exception> 类中，what（）函数似乎无法正常工作

Question

in this particular program I implemented a deque. the only problem seems to be my error handling. here is the relevant code:

#include <exception>

class Deque {
    public:
        class RemoveError : exception {
            public:
                 virtual const char* what() const noexcept {
                     return "error: cannot remove element; the queue is empty";
            }
        }R_error;

        T removeFirst() throw(RemoveError);
};

Deque::removeFirst() throw(RemoveError) {
    if (isEmpty()) 
        { throw R_error; }
}

int main () {
    try {
        Deque Q;
        printf ( "this should be an error :%d\n", Q.removeFirst ( ) );
    }
    catch(exception& e) {
        printf ( e.what(), '\n');
    }
}

and yet, when I deliberately try to remove one too many nodes from my deque, the error on the screen is

terminate called after throwing an instance of 'Deque::RemoveError

instead of

error: cannot remove element; the queue is empty

I have tried both using and not using the virtual in my what() function, and I tried throwing RemoveError() instead of R_error .

is there any reason this is happening? I tried to find an answer on here but couldn't find this particular problem.

edit: as noted below, I had my exceptions private; changing

class RemoveError : exception {

to either

struct RemoveError : exception {
class RemoveError : public exception {

fixed it. Thanks everyone for your help

Answer 1

That error message gets produced by g++ default uncaught exception handler, see Verbose Terminate Handler :

The __verbose_terminate_handler function obtains the name of the current exception, attempts to demangle it, and prints it to stderr. If the exception is derived from exception then the output from what() will be included.

But in:

class RemoveError : exception

std::exception is not a public base class of RemoveError , hence that exception handler cannot call its what function.

Fix:

class RemoveError : public exception

Or:

struct RemoveError : exception

---

Note 1:

virtual const char* what() const noexcept

Should be:

const char* what() const noexcept override

---

Note 2:

T removeFirst() throw(RemoveError);

Exception specification is depricated in C++11. That should be just plain:

T removeFirst();

Answer 2

terminate called after throwing an instance of 'Deque::RemoveError'

std::terminate was called as there was an active exception that, through stack unwinding, was not caught.
In order to retrieve the message thrown along with the exception you have to catch the exception somewhere and call what .

{
    try {
        // code that might throw
    } catch(RemoveError e) {
       std::cerr << e.what() << std::endl;
    }
}