Throwing a custom exception in Visual C++ 2019 - visual-studio

Question

MFC defines functions to throw predefined exceptions. For example, you use ::AfxThrowFileException() to throw an exception of type CFileException. But what if I define my own exception class, which derives from CException? What is the preferred way to throw it?
Are there problems if I simply do this:
if (!m_Settings.IsValid())
throw new CMyException(_T("This operation failed."));
In Visual Studio 2019, the code above generates the following Intellisense warning. But I've yet to see any examples throwing an exception using make_unique.
Warning C26409 Avoid calling new and delete explicitly, use std::make_unique instead (r.11).
Can anyone explain this, or refer me to some current documentation?

Answer 1

Exception handling is one of those areas where it shows, that MFC predates C++ by a fair amount. With C++ exceptions being a late addition to the C++ Standard, MFC had already decided on its exception handling strategy:
Allocate exception objects on the freestore.
Throw by pointer.
Catch by pointer.
Any catch clause that handles an exception is required to release resources associated with the exception object.
By contrast, the idiomatic way to handle C++ exceptions follows these guidelines:
Throw exception objects with automatic storage duration by value.
Catch by (const) reference.
Cleanup of resources is handled automatically.
With MFC you can use either of the above. MFC provides exception macros to help make the former less error prone, although there is no strict requirement to use any of them. In fact, the exception macros in version 3.0 have moved on to almost exclusively use C++ exception handling under the hood.
The correct way to throw custom exceptions in MFC depends on the code that calls it. If that code is using the MFC exception macros, you will need to throw a pointer to the dynamically allocated exception object, e.g.
throw new CMyException(_T("This operation failed."));
or
THROW( (CException*) new CMyException(_T("This operation failed.")) );
and ignore the compiler warning. This is required because the CATCH macros will always expand to catch clauses matching pointer types.
If, on the other hand, calling code uses C++ exception handling, there's no issue throwing either by value or pointer, e.g.
throw CMyException(_T("This operation failed."));
// or
throw new CMyException(_T("This operation failed."));
and catching by const reference or pointer:
catch( CException const& ) {
// no cleanup required
}
// or
catch( CException* e ) {
// manual cleanup still required, unless the exception is re-thrown
e->Delete();
}
In the previous snippet it is also allowed to use both catch clauses, allowing you to provision your calling code to deal with a mixture of throwing custom exceptions by value in your code as well as calling into MFC-provided code that raises dynamically allocated exception objects thrown by pointer.
It is even allowed, to some extent, to mix C++ exception handling and MFC exception macros (Exceptions: Using MFC Macros and C++ Exceptions). The information is provided for completeness only. It is not recommended to mix C++ exceptions and MFC exception macros, unless there is a good reason to do so, e.g. when gradually transitioning existing code from MFC exception macro use to C++ exception handling.