登录异常构造函数是不好的做法吗？

Question

1.) What kind of exception logging is the better practice?

           //1 xor //2

2.) Is this question language specific? (Most interested in c++)

To the code:

:: LOG is macro for singleton-logger

struct myExc : virtual std::runtime_error
{
    myExc( std::string const&msg )
    :runtime_error(msg)
    {
        LOG << msg;    //1
    }
};

void foo_throw()
{
   throw myExc("");
}


/// some_where
...
try()
{
    foo_throw();
}
catch( myExc const& e)
{
    LOG << e.what();     //2
}
catch(...

Answer 1

The second variant is preferable, because some code further up the call stack could choose to catch the exception without outputting an error. In the first version, you output as soon as the exception is created, thus giving catching code less choice.

For example, you might do something like this:

try
{
    foo_throw();
}
catch (myExc& e)
{
    //do some recovery
}

If your exception constructor outputs something, you can't do anything about it when catching said exception.

Answer 2

The first one is probably 'too smart'. And do you sure about that the LOG << cannot throw exception? In second case you have more information and more possibilities to consider what happen if LOG << throws, especially you can do obligatory safe stuff before log.

And first case tried to does two things: inform about exception and log message. This is bad. In second case you only inform about exception and after that you handle it: do stuff and log.

Second case is example of separation of responsibility where one class does one task.

Also yours exception class is free from dependency of logger which is also good stuff.