Re: CException class implementation
On Oct 4, 9:49 pm, mfc <mfcp...@googlemail.com> wrote:
Hi,
I`m trying to install a derived class from the CException class. The
goal I want to acchieve is that any exception will be also included in
a std::map or in a normal list. This list is installed in the derived
exception class. Therefore I will install one global MyExceptionClass
member variable g_ex; which will be available in each class. (Or is
there a better way?)
On my webserver, there`s one page which will include a table, which
should show all available exceptions.
//MyExceptionClass ex;
//global variable
g_ex;
//specific error code
#define LOAD_XML_FILE_FAILED 1120;
if(!(XmlFile.LoadUserXml(strFileName)))
{
TCHAR szCause[255];
g_ex.GetErrorMessage(szCause, 255);
g_ex.AddtoList(LOAD_XML_FILE_FAILED, szCause);
return FALSE;
}
How long could be such a exception message created by the MFC
directly? Or is it much better to create my own message and add this
message to the list?
In all honesty, you are not making a lot of sense.
In your code snippet with XML file, you have no exceptions at all, you
have a textual error message (or perhaps a list thereof, but you are
not showing it), that you are putting into random exception class
instance.
It looks like your goal is to collect some sort of error log. Is this
correct? If so, then, what's wrong with creating a log? Why would an
exception class and some global variable play any role in that? How
about e.g. this:
void Work(CStringArray& errors, other params)
{
if (!subTask1(...))
errors.Add(createErrorTextForFailureInSubTask1());
// rinse, repeat
}
and then e.g.
CStringArray errors;
Work(errors, other params);
if (!errors.IsEmpty())
{ // throw exception? log?
// you choose
}
Do you know a good method to store all these error codes (e.g.
LOAD_XML_FILE_FAILED)? At the moment I use another headerfile, which
will be included in each class containing all these #defines.
Putting "all" error codes together is a good idea only if they are not
going to change often and you will use them from a pre-compiler header
(e.g. if you create a library). If not, it is a mighty bad idea. If
you put them together, and if they represent errors in several
unrelated parts of your code, you will create compile-time dependency
for __all__ parts of the code that use your header, even though any
given part of the code needs only a small part of the complete error
code list.
Goran.