Re: Simulating new user-defined operators
Michael Aaron Safyan ha scritto:
For the second example, functions should throw exceptions, by default.
If you don't want a function to throw exceptions, then they should be
explicitly disabled as in the following:
disable_exceptions{
// code which normally throws exceptions ceases to throw exceptions
}
I really don't see the relationship with the OP's example. Moreover, it
seems to me that it's a bad idea in the first place: if a function is
designed to throw an exception to return an error condition and you
disallow that, what should the function do to return the error
condition? If the function calls a library function which is not under
your control, how can you disallow exception thrown by the library
function? In the end, it's much safer to wrap the code in a try/catch
block rather than using your approach.
The above can be implemented with something along the lines of:
class ExceptionDisabler
{
public:
ExceptionDisabler() : _test(true) {
ExceptionManager::push(false); // disable
}
~ExceptionDisabler(){
ExceptionManager::pop(); // restore
}
void operator++(){ _test = false; }
void operator++(int){ _test = false; }
operator bool()const{ return _test; }
private:
bool _test;
};
#define TOKENCAT(X,Y) TOKENCAT2(X,Y)
#define TOKENCAT2(X,Y) X ## Y
#define disable_exceptions \
for ( ExceptionDisabler TOKENCAT(ed,__LINE__); \
TOKENCAT(ed,__LINE__); \
TOKENCAT(ed,__LINE__)++ ) \
BTW, there is simpler a way of implementing this that doesn't require a
loop:
class ExceptionDisabler
{
public:
ExceptionDisabler(int) {
ExceptionManager::push(false); // disable
}
~ExceptionDisabler() {
ExceptionManager::pop(); // restore
}
operator bool() const { return false; }
};
#define TOKENCAT(X,Y) TOKENCAT2(X,Y)
#define TOKENCAT2(X,Y) X ## Y
#define disable_exceptions \
if (ExceptionDisabler TOKENCAT(ed,__LINE__) = 0) {} else
HTH,
Ganesh
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]