Re: Simulating new user-defined operators

Using operator% in this manner would never pass my code review, because
this usage has absolutely nothing to do with taking the modulus of a
value, and -- therefore -- this usage is unintuitive.

For the first example, why write "to_euros % some_value" when you can
just as easily write "to_euros(some_value)"?

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
}

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__)++ ) \

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]