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 relation****p 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! ]
|
