What is the difference between catch(...) vs catch(CException *)?

Question

CException is the base type of all exceptions thrown by VC++, so it should catch all the exceptions, right?

Answer 1

CException is not the base type for all extensions (it might be the base type of all exceptions that MFC code uses, but that's as far as it goes).

In C++, you can throw anything; it doesn't have to be an "exception" subclass, and it does not even have to be an object. It's perfectly legal for example to write throw 42; or throw new std::vector<string>();

The difference is then obvious: catch(CException) will catch only thrown instances of CException and its subclasses, while the other will catch anything.

Answer 2

C++ exceptions can be of any type. With a catch() you specify the type of the exception you want to catch as a parameter. The special case with (...) is that you will catch any other exception you didn't specified in the earlier catches.

The base of exceptions in C++ for the Standard library is std::exception. To catch all exceptions, the standard way in a C++ program is the following:

(in a main function for instance)

try
{

}
catch( const std::exception & e )
{
// catch standard exceptions, you can use e.what() to know what exception you caught
}
catch( ... )
{
// catch all other types but you can't do much with them
}

It is not recommended, even if it's possible, to throw your own exceptions that do not inherit from std::exception. But CException do not seem to inherit from it.

In your case, I'll advise you to do the following to catch all exceptions that might arise (again, for instance in your main function and in the main thread functions):

try
{
}
catch( const CException & e )
{
// catch all CExceptions
//as far as I know it is ok now to catch CException by reference with modern Microsoft compilers? It was not always the recommended microsoft way
}
catch( const std::exception & e )
{
// catch standard C++ exception
}
catch( ... )
{
// catch others
}

As always, when not used to it, it may be tricky to know what is standard C++ and what is windows API.

Answer 3

throw "ex";

will actually throw a string (well, const char*, but you know what I mean).

catch (TYPE t)

will only catch objects of type TYPE (doesn't have to be an exception).