[Feature Request] Please make Exception::what() return sensible what message.

[Smurf-IV]

i.e.

const char* Exception::what() const noexcept
{
	return displayText().c_str();
}

So that "Normal exception handlers can see the following style "Rich Text"
Cannot load library: Error 126 while loading [LocalDbStorage1.dll]: [The specified module could not be found.]

and not the current obscure Cannot load library

[obiltschnig]

Not possible, as displayText() returns a newly created std::string (not a reference to an existing instance), and the result of c_str() would be deleted when what() returns.

[Smurf-IV]

Ok.

const char* Exception::what() const noexcept
{
    static std::string DoNotTidyOnExit{ displayText() };
	return DoNotTidyOnExit.c_str();
}

Or use an allocated buffer like in the std::exception

[andrewauclair]

Making it a static std::string inside of what is a bad idea imo. Only real option would be to precalcuate the display text and store it in a member variable. I'm guessing the difficulty there is deciding where to call displayText because of child classes.

[Smurf-IV]

Making it a static std::string inside of what is a bad idea imo

If the exception thrown is due to memory pressure then I would agree.
But,

• Pre calculating means that every exception (even if not used ) would have allocated memory
• The memory allocated for the static is only done when the exception message is needed (But then may hang around for a while for that exception type)
• Better would be a class string field, that is populated in a what call only.
• Something else ?

[Smurf-IV]

Taking each point in turn:

1: Pre calculating means that every exception (even if not used ) would have allocated memory

Not a big problem, but see explanation for 3

2: The memory allocated for the static is only done when the exception message is needed (But then may hang around for a while for that exception type)

Unfortuantely this means that due to some optimisation(s), the next exception will internally see that the static has been allocated and return the first instance !!

3: Better would be a class string field, that is populated in a what call only.

But the whatcall is an overridden virtual that has the const specifier on it, therefore cannot modify any class field !!

4: Something else ?

So this is what I'm using currently:

    catch (std::exception& ex)
    {
        TraceCatch(ex);
1        std::string msg{ ex.what() };
2       if (Poco::Exception* pex = dynamic_cast<Poco::Exception*>(&ex); 
3            pex != nullptr)
4       {
5           msg = pex->displayText();
6        }
        Events evt;
        evt.StatsFileTsIdID(tsId)
            .Status(LR::SR::LE::IngestSvcDto::FileStatus::Error)
            .Message(std::format("Error [{}]", msg))
            .create(pContext);
    }

It would be nice if there is a neater way to do lines 1 -> 6

[matejk]

Cleaner way to do it would perhaps be something like:

std::string msg;
try
    {
// Some code
    }
catch (const PocoException& ex)
    {
           msg = ex->displayText();
    }
catch (const std::exception& ex)
    {
        TraceCatch(ex);
        std::string msg{ ex.what() };
    }
catch(...)
    {
// Do something for all other exceptions
    }

Events evt;
evt.StatsFileTsIdID(tsId)
    .Status(LR::SR::LE::IngestSvcDto::FileStatus::Error)
    .Message(std::format("Error [{}]", msg))
    .create(pContext);