# V2010. Handling of two different exception types is identical.

This diagnostic rule was added at users' request.

The analyzer has detected an issue when handlers for different exception types do the same job. It may be an error or it may signal that the code can be reduced.

For example:

    try
    {
      ....
    }
    catch (AllocationError &e)
    {
      WriteLog("Memory Allocation Error");
      return false;
    }
    catch (IOError &e)
    {
      WriteLog("Memory Allocation Error");
      return false;
    }

This code fragment was written using the Copy-Paste method, which leads to writing an incorrect error message into the log in case of a reading from file error. The code should actually look something like this:

    try
    {
      ....
    }
    catch (AllocationError &e)
    {
      WriteLog("Memory Allocation Error");
      return false;
    }
    catch (IOError &e)
    {
      WriteLog("IO Error: %u", e.ErrorCode());
      return false;
    }

Here is another example. The code below is correct but can be reduced:

    try
    {
      ....
    }
    catch (std::exception &)
    {
      Disconnect();
    }
    catch (CException &)
    {
      Disconnect();
    }
    catch (...)
    {
      Disconnect();
    }

Since all the handlers are identical and catch exceptions of all types, the code can be shortened:

    try
    {
      ....
    }
    catch (...)
    {
      Disconnect();
    }

Another example.

    class DBException : public std::exception { ... };
    class SocketException : public DBException { ... };
    class AssertionException : public DBException { ... };
    ....
    try
    {
      ....
    }
    catch (SocketException& e){
      errorLog.push_back(e.what());
      continue;
    }
    catch (AssertionException& e) {
      errorLog.push_back(e.what());
      continue;
    }
    catch(std::exception& e){
      errorLog.push_back(e.what());
      continue;
    }

There are a few classes inherited from the 'std::exception' class. All the exception handlers are identical. Notice that they also catch exceptions of the 'std::exception' type among others. This code is redundant. We may leave only one handler for 'std::exception', and it will catch and handle all the rest exceptions alike as they are inherited from 'std::exception'. The 'what()' method is virtual, so a correct error message will be saved into 'errorLog'.

The simplified code:

    try
    {
      ....
    }
    catch(std::exception& e){
      errorLog.push_back(e.what());
      continue;
    }