Why catch block of base class is catching the exception when I am throwing object of derived class? [duplicate]

Question

if I am passing object of derived class, then the derived class catch block should be invoked. But the output says that the exception is caught by the base class. Why?

#include<iostream>
using namespace std;

class Base {};
class Derived: public Base {};
int main()
{
   Derived d;
   // some other stuff
   try {
       // Some monitored code
       throw d;
   }
   catch(Base b) { 
        cout<<"Caught Base Exception";
   }
   catch(Derived d) {  //This catch block is NEVER executed
        cout<<"Caught Derived Exception";
   }
   getchar();
   return 0;
}

Answer 1

The standard says (see [except.handle]/4] of the working draft as an example, emphasis mine):

The handlers for a try block are tried in order of appearance. [ Note: This makes it possible to write handlers that can never be executed, for example by placing a handler for a final derived class after a handler for a corresponding unambiguous public base class.

This is exactly what you did in your code.
Therefore I'd say that's the intended behavior, no matter what was your expectations.

Note that you can swap the two handlers to solve the issue.

Answer 2

There is a little to be said about this.

Firstly, it is good practice to catch exceptions by reference instead of value. This prevents slicing of the exception object in the case that it is derived. This is not specific to exceptions but a general feature of inheritance.

A description of this phenomena is discussed here

Also, as pointed out by another answer, if you insist on doing things this way you need to change the order of catches, as a derived class satisfies the base catch block. There is another way of doing this though that uses this property explicitly: Just have the base class catch everything. You can use this unless there is a very specific feature of the derived exception that needs to be treated separately

Answer 3

The catch clauses are checked in order - you get first match, not best match.

So checking the derived type first would catch that.