ExceptionHandle r class & list of error messages ?

[mast2as]

Hi everyone... I have a TExceptionHandl er class that is uses in the
code to thow exceptions. Whenever an exception is thrown the
TExceptionHande r constructor takes an error code (int) as an argument.
I was hoping to create a map<int, const char*that would be used in
the showError member function of the TExceptionHandl er class where the
key (int) would be the error code and const char* the message printed
out to the console.

My question is the following. What would be the best way of creating
that map ? Here is why I am asking. I believe when you throw an
exception you actually create a copy of the object TExceptionHandl er.
So if the map is a member variable of the class and that each entry in
the map is intialised with a string (as an error message) it would be a
waste of CPU time & memory (just stupide to create that list eveytime a
TExceptionHandl er object is created).

Is the best way, to make the TExceptionHandl er class a singleton ? The
map could a static member variable and would be intialised only once.
Or should I make the map a global variable (like an array of const
char* or string) and just use that global variable in the showError()
function ?

I am sure there's a good way of doing that ;-)

I looked on the net and the groups' archives but couldn't find anything
related on that precise aspect of exception handling.

thank you, mark

(ps I know i ask a lot to the group at the moment, but i also learn a
lot from you guys ! I hope i'll be able to help other people one
day...)

class TExceptionHandl er
{
public:
TExceptionHandl er( int error ) :
m_code( error ),
m_severity( GIE_ERRORPRINT ),
m_message( "" )
{}

TExceptionHandl er( int error, int severity ) :
m_code( error ),
m_severity( severity ),
m_message( "" )
{}

~TExceptionHand ler() {}
void showError()
{
// print out the error message base of the error code
cout << globalErrorMess ageList[ m_error ] << endl; << is that the
best option ?
}
private:
int m_code;
int m_severity;
const char* m_message;
};

// The class used somewhere in the code
try {
popModel( TAppliState::kM odelA );
} catch ( TExceptionHandl er &e ) {
e.showError();
}

[mast2as]

oops sorry there's a typo mistake it should be

cout << globalErrorMess ageList[ m_code ] << endl;

// print out the error message base of the error code
cout << globalErrorMess ageList[ m_error ] << endl; << is that the

[Vikram]

ma*****@yahoo.c om wrote:

Hi everyone... I have a TExceptionHandl er class that is uses in the
code to thow exceptions. Whenever an exception is thrown the
TExceptionHande r constructor takes an error code (int) as an argument.
I was hoping to create a map<int, const char*that would be used in
the showError member function of the TExceptionHandl er class where the
key (int) would be the error code and const char* the message printed
out to the console.

My question is the following. What would be the best way of creating
that map ? Here is why I am asking. I believe when you throw an
exception you actually create a copy of the object TExceptionHandl er.
So if the map is a member variable of the class and that each entry in
the map is intialised with a string (as an error message) it would be a
waste of CPU time & memory (just stupide to create that list eveytime a
TExceptionHandl er object is created).

Is the best way, to make the TExceptionHandl er class a singleton ? The
map could a static member variable and would be intialised only once.
Or should I make the map a global variable (like an array of const
char* or string) and just use that global variable in the showError()
function ?

Why not just detach the error code and the map? Have separate classes
TExceptionCode and TExceptionHandl er. Have the map and all the logic in
the handler and just throw the TExceptionCode object rather than
Handler.

[mlimber]

ma*****@yahoo.c om wrote:

Hi everyone... I have a TExceptionHandl er class that is uses in the
code to thow exceptions. Whenever an exception is thrown the
TExceptionHande r constructor takes an error code (int) as an argument.
I was hoping to create a map<int, const char*that would be used in
the showError member function of the TExceptionHandl er class where the
key (int) would be the error code and const char* the message printed
out to the console.

My question is the following. What would be the best way of creating
that map ? Here is why I am asking. I believe when you throw an
exception you actually create a copy of the object TExceptionHandl er.
So if the map is a member variable of the class and that each entry in
the map is intialised with a string (as an error message) it would be a
waste of CPU time & memory (just stupide to create that list eveytime a
TExceptionHandl er object is created).

Is the best way, to make the TExceptionHandl er class a singleton ? The
map could a static member variable and would be intialised only once.
Or should I make the map a global variable (like an array of const
char* or string) and just use that global variable in the showError()
function ?

I am sure there's a good way of doing that ;-)

I looked on the net and the groups' archives but couldn't find anything
related on that precise aspect of exception handling.

Why not make it a private static member in your class:

class TException
: std::exception
{
public:
enum ErrorCode
{
SOMETHING_HAPPE NED = 1,
SOMETHING_ELSE = 5,
SOMETHING_STRAN GE = 42
};

typedef std::map<ErrorC ode, const char*MsgMap;

// Only one constructor is needed
TException(
const ErrorCode code,
const int severity = GIE_ERRORPRINT )
: m_code( error )
, m_severity( severity )
{}

virtual const char* what() const
{
return msgMap_[ code_ ];
}

int severity() const
{
return severity_;
}

private:
const static MsgMap msgMap_;
const ErrorCode code_;
const int severity_;
};

Then in the .cpp file, use an initializer helper class to initialize
it:

namespace // anonymous
{
class MsgMapInitializ er
{
TException::Msg Map m_;
public:
operator TException::Msg Map() const { return m_; }

MsgMapInitializ er& Add( const int i, const char* s )
{
m_[i] = s;
return *this;
}
};
}

const TException::Msg Map TException::msg Map_ = MsgMapInitializ er()
.Add( TException::SOM ETHING_HAPPENED , "Msg 1" )
.Add( TException::SOM ETHING_ELSE, "Msg 2" )
.Add( TException::SOM ETHING_STRANGE, "Msg 3" );

Then you can use it like this:

try
{
throw TException( TException::SOM ETHING_ELSE, 100 );
}
catch( const std::exception& e )
{
std::cerr << e.what() << std::endl; // Or whatever
}

[snip]

void showError()
{
// print out the error message base of the error code
cout << globalErrorMess ageList[ m_error ] << endl; << is that the
best option ?
}

Typically it is best to inherit from std::exception and override the
virtual function what() to return an error message. Then the user can
do whatever s/he wants with it rather than being forced to use cout
(which is often impractical in GUI and embedded applications).

private:
int m_code;
int m_severity;
const char* m_message;
};

Why store the message locally? Just look it up when its time to use it
(probably only once).

Cheers! --M

[mast2as]

Thanks a lot for your help. They are 2 good ideas... and things I
wasn't sure how to implement ;-)

m_message wasn't intended to be the message attached to an error code.
I wanted to use it to have an additional error message to the
predifined one.

For example:

#define GIE_UNIMPLEMENT ED

errorMessages[ GIE_UNIMPLEMENT ED ] = "feature is not implemented";

throw( TExceptionHande r( GIE_UNIMPLEMENT ED, GIE_PRINTERROR, "carrot is
not a fruit !" ) );
....
catch( TExceptionHandl er &e ) {
cout << e.what() << endl; // prints out "feature is not implemented
(carrot is not a fruit)";
}

thanks again.

[mast2as]

Hi I tried to "copy" your code (the names are a bit different) and i
get an error when i compile which i don't understand well... could you
help me a bit more please ? thank you...

/////// COMPILE ERROR

test.cpp: In member function `virtual const char* TException::wha t()
const':
test.cpp:28: error: passing `const std::map<const int, const char*,
std::less<const int>, std::allocator< std::pair<const int, const char*>

' as `this' argument of `_Tp& std::map<_Key, _Tp, _Compare, _Alloc>::operat or[](const _Key&) [with _Key = const int, _Tp = const char*, _Compare = std::less<const int>, _Alloc = std::allocator< std::pair<const int, const char*]' discards qualifiers

/////// CODE

#include <iostream>
#include <deque>
#include <map>
#include <exception>

#define PRINTERROR 0
#define ABORTERROR 1

class TException : public std::exception
{
public:
enum errorCode {
TEST1 = 1,
TEST2,
TEST3
};
typedef std::map<const int, const char*MsgMap;
public:
TException( const int code, const int severity = PRINTERROR ) :
m_code( code ),
m_severity( severity )
{}

~TException() throw() {}

virtual const char* what() const throw()
{
return myMsgMap[ m_code ];//"some text";
}
public:
private:
const int m_severity;
const int m_code;
const static MsgMap myMsgMap;
};

namespace
{
class TInitialise
{
public:
TException::Msg Map m_;
public:
operator TException::Msg Map() const { return m_; }
TInitialise() {};
TInitialise &Add() { std::cout << "in add\n"; return *this; }
};
}

const TException::Msg Map TException::myM sgMap = TInitialise()
.Add()
.Add();

int main()
{
return 0;
}

[mlimber]

ma*****@yahoo.c om wrote:

Hi I tried to "copy" your code (the names are a bit different) and i
get an error when i compile which i don't understand well... could you
help me a bit more please ? thank you...

/////// COMPILE ERROR

test.cpp: In member function `virtual const char* TException::wha t()
const':
test.cpp:28: error: passing `const std::map<const int, const char*,
std::less<const int>, std::allocator< std::pair<const int, const char*>

>' as `this' argument of `_Tp& std::map<_Key, _Tp, _Compare, _Alloc>::operat or[](const _Key&) [with _Key = const int, _Tp = const char*, _Compare = std::less<const int>, _Alloc = std::allocator< std::pair<const int, const char*]' discards qualifiers

/////// CODE

#include <iostream>
#include <deque>

FYI, this header isn't used (but maybe that's because you deleted the
code that referenced it for simplicity).

#include <map>
#include <exception>

#define PRINTERROR 0
#define ABORTERROR 1

Prefer const ints or (better) an enumeration to these defines since
macros are evil (cf.
http://www.parashift.com/c++-faq-lit...s.html#faq-9.5)
and should be avoided in favor of C++ constructs when possible. These
two lines won't likely cause a problem, but it's better to be in the
habit of doing things correctly.

>
class TException : public std::exception
{
public:
enum errorCode {
TEST1 = 1,
TEST2,
TEST3
};
typedef std::map<const int, const char*MsgMap;

The problem is the const on the int. The map's key type is always made
const, and so you can't add that qualifier here lest you end up with a
"const const int". However, you should change the key type to errorCode
for an added bit of type safety.

public:
TException( const int code, const int severity = PRINTERROR ) :

Change this int to errorCode, too, for type safety. It won't guarantee
that the user doesn't cast an invalid integer value into your
enumeration type, but it will be helpful for non-devious users. For
instance, this line wouldn't compile if you made this change:

throw TException( 42 );

but this line would:

throw TException( 1 );

The latter is less explicit and more prone to accidents than the
equivalent "TException ( TException::TES T1 )". Prefer to use your
enumeration to help the programmer use your class correctly.

m_code( code ),
m_severity( severity )
{}

~TException() throw() {}

virtual const char* what() const throw()
{
return myMsgMap[ m_code ];//"some text";
}

There's another problem here. I didn't actually try compiling the code
before, and I overlooked the fact that the [] operator for map isn't
const, and since the map is (rightly) declared const in your class, you
can't call non-const methods on it (cf.
http://www.parashift.com/c++-faq-lit...html#faq-18.10
and
http://www.parashift.com/c++-faq-lit...tml#faq-18.12).
The correct version of this function is:

virtual const char* what() const throw()
{
const MsgMap::const_i terator iter = myMsgMap.find( m_code );
if( iter != myMsgMap.end() )
{
return iter->second;
}
return "No error message found!";
}

public:
private:
const int m_severity;
const int m_code;

Change this to errorCode as well.

const static MsgMap myMsgMap;
};

Remember, the following lines need to be in a .cpp file somewhere, not
a header.

>
namespace
{
class TInitialise
{
public:
TException::Msg Map m_;
public:
operator TException::Msg Map() const { return m_; }
TInitialise() {};
TInitialise &Add() { std::cout << "in add\n"; return *this; }
};
}

const TException::Msg Map TException::myM sgMap = TInitialise()
.Add()
.Add();

int main()
{
return 0;
}

Cheers! --M

[mast2as]

Hi Thank you again...

I will do the changes you mention. It is true that for the test code i
went for the easiest way sometimes like the #define thing but was
planning to write it the proper way (as well as the casting but as I
got problem compiling it i tried to simplify the whole program).

This the first I see this syntax ?

const TException::Msg Map TException::myM sgMap = TInitialise()
.Add()
.Add();

Would you have a link where I can read about it ? (calls to the .Add()
function)

Thanks again for your help and advices.

mark

mlimber wrote:

ma*****@yahoo.c om wrote:

Hi I tried to "copy" your code (the names are a bit different) and i
get an error when i compile which i don't understand well... could you
help me a bit more please ? thank you...

/////// COMPILE ERROR

test.cpp: In member function `virtual const char* TException::wha t()
const':
test.cpp:28: error: passing `const std::map<const int, const char*,
std::less<const int>, std::allocator< std::pair<const int, const char*>

' as `this' argument of `_Tp& std::map<_Key, _Tp, _Compare, _Alloc>::operat or[](const _Key&) [with _Key = const int, _Tp = const char*, _Compare = std::less<const int>, _Alloc = std::allocator< std::pair<const int, const char*]' discards qualifiers

/////// CODE

#include <iostream>
#include <deque>

FYI, this header isn't used (but maybe that's because you deleted the
code that referenced it for simplicity).

#include <map>
#include <exception>

#define PRINTERROR 0
#define ABORTERROR 1

Prefer const ints or (better) an enumeration to these defines since
macros are evil (cf.
http://www.parashift.com/c++-faq-lit...s.html#faq-9.5)
and should be avoided in favor of C++ constructs when possible. These
two lines won't likely cause a problem, but it's better to be in the
habit of doing things correctly.

class TException : public std::exception
{
public:
enum errorCode {
TEST1 = 1,
TEST2,
TEST3
};
typedef std::map<const int, const char*MsgMap;

The problem is the const on the int. The map's key type is always made
const, and so you can't add that qualifier here lest you end up with a
"const const int". However, you should change the key type to errorCode
for an added bit of type safety.

public:
TException( const int code, const int severity = PRINTERROR ) :

Change this int to errorCode, too, for type safety. It won't guarantee
that the user doesn't cast an invalid integer value into your
enumeration type, but it will be helpful for non-devious users. For
instance, this line wouldn't compile if you made this change:

throw TException( 42 );

but this line would:

throw TException( 1 );

The latter is less explicit and more prone to accidents than the
equivalent "TException ( TException::TES T1 )". Prefer to use your
enumeration to help the programmer use your class correctly.

m_code( code ),
m_severity( severity )
{}

~TException() throw() {}

virtual const char* what() const throw()
{
return myMsgMap[ m_code ];//"some text";
}

There's another problem here. I didn't actually try compiling the code
before, and I overlooked the fact that the [] operator for map isn't
const, and since the map is (rightly) declared const in your class, you
can't call non-const methods on it (cf.
http://www.parashift.com/c++-faq-lit...html#faq-18.10
and
http://www.parashift.com/c++-faq-lit...tml#faq-18.12).
The correct version of this function is:

virtual const char* what() const throw()
{
const MsgMap::const_i terator iter = myMsgMap.find( m_code );
if( iter != myMsgMap.end() )
{
return iter->second;
}
return "No error message found!";
}

public:
private:
const int m_severity;
const int m_code;

Change this to errorCode as well.

const static MsgMap myMsgMap;
};

Remember, the following lines need to be in a .cpp file somewhere, not
a header.

namespace
{
class TInitialise
{
public:
TException::Msg Map m_;
public:
operator TException::Msg Map() const { return m_; }
TInitialise() {};
TInitialise &Add() { std::cout << "in add\n"; return *this; }
};
}

const TException::Msg Map TException::myM sgMap = TInitialise()
.Add()
.Add();

int main()
{
return 0;
}

Cheers! --M

[mlimber]

ma*****@yahoo.c om wrote:

This the first I see this syntax ?

const TException::Msg Map TException::myM sgMap = TInitialise()
.Add()
.Add();

Would you have a link where I can read about it ? (calls to the .Add()
function)

First, please put your responses below or inline the message you are
responding to. That's the custom here.

As for that syntax, see these two FAQs:

http://www.parashift.com/c++-faq-lit...s.html#faq-8.4
http://www.parashift.com/c++-faq-lit...html#faq-10.17

At the moment, this site seems to be having problems. Here's a
(possibly out-dated) mirror:

http://geneura.ugr.es/~jmerelo/c++-f...s.html#faq-8.4
http://geneura.ugr.es/~jmerelo/c++-f...html#faq-10.17

Cheers! --M

[mast2as]

First, please put your responses below or inline the message you are
responding to. That's the custom here.

Here is a version of the code that works. Because i found it really
interesting (I quite a few new tricks) I thought I would post a
complete version that compiles and runs. Hopefully doing all the
changes you mentionned. I just removed const. Not sure it was really
necessary but this way i could make your first version of the code
work.

Thank you again your help -

#include <iostream>
#include <deque>
#include <map>
#include <exception>

class TException : public std::exception
{
public:

enum errorCode
{
kTest1 = 1,
kTest2 = 10,
kTest3 = 12,
kTest4 = 20
};

// error severity levels
//
// #define RIE_INFO 0
// #define RIE_WARNING 1
// #define RIE_ERROR 2
// #define RIE_SEVERE 3

enum severityLevel
{
kInfo = 0, // Rendering stats and other info
kWarning, // Something seems wrong, maybe okay
kError, // Problem. Results may be wrong
kSevere // So bad you should probably abort
};

// error handlers codes
//
// #define RIE_ERRORIGNORE 0
// #define RIE_ERRORPRINT 1
// #define RIE_ERRORABORT 2

enum handlerCode
{
kErrorIgnore = 0,
kErrorPrint,
kErrorAbort,
};

typedef std::map<TExcep tion::errorCode , const char*MsgMap;

public:
TException( TException::err orCode code, TException::han dlerCode
handler =
kErrorIgnore, TException::sev erityLevel severity = kInfo ) :
m_error( code ),
m_severity( severity ),
m_handler( handler )
{}

~TException() throw() {}

const char* what() const throw()
{
return myMsgMap[ m_error ];
}

private:
TException::err orCode m_error;
TException::han dlerCode m_handler;
TException::sev erityLevel m_severity;

static MsgMap myMsgMap;
};

class MsgMapInitializ er
{
TException::Msg Map m_;
public:
operator TException::Msg Map() const { return m_; }
MsgMapInitializ er& Add( TException::err orCode error, const char * msg
)
{
m_[ error ] = msg;
return *this;
}
};

TException::Msg Map TException::myM sgMap = MsgMapInitializ er()
.Add( TException::kTe st1, "test1" )
.Add( TException::kTe st2, "test2" )
.Add( TException::kTe st3, "test3" );

int main()
{
try {
// throw something
throw( TException( TException::kTe st1, TException::kEr rorPrint,
TException::kWa rning ) );
} catch( TException &e ) {
std::cout << e.what() << std::endl;
};
return 0;
}