# V2539. MISRA. Class destructor should not exit with an exception.

This diagnostic rule is based on the software development guidelines developed by MISRA (Motor Industry Software Reliability Association).

This rule only applies to C++. Throwing an exception in the object destructor is a bad practice. Starting from C++11 throwing an exception in the destructor body leads to call of the function 'std::terminate'. What follows from this is that an exception thrown inside a destructor must be handled inside the same destructor.

Let's look at the first example:

    LocalStorage::~LocalStorage()
    {
      ...
      if (!FooFree(m_index))
        throw Err("FooFree", GetLastError());
      ...
    }

The analyzer has detected a destructor containing the throw statement outside the try..catch block. This code should be rewritten so that it reports an error in the destructor without using the exception mechanism. If the error is not critical, then it can be ignored:

    LocalStorage::~LocalStorage()
    {
      try {
        ...
        if (!FooFree(m_index))
          throw Err("FooFree", GetLastError());
        ...
      }
      catch (...)
      {
        assert(false);
      }
    }

Exceptions can also occur when calling the 'new' operator. If you cannot allocate memory, the 'std::bad_alloc' exception will be thrown. Let's consider the second example:

    A::~A()
    {
      ...
      int *localPointer = new int[MAX_SIZE];
      ...
    }

An exception can also occur when the dynamic_cast operator is applied to references. If the cast is impossible, the exception 'std::bad_cast' will be generated. Let's consider the third example:

    B::~B()
    {
      ...
      UserType &type = dynamic_cast<UserType&>(baseType);
      ...
    }

To fix these errors the code should be rewritten so that 'new' or 'dynamic_cast' would be placed in the 'try-catch' block.

This diagnostic is classified as:

MISRA-CPP-2008-15.5.1