Daryle Walker wrote:In <boost/operators.hpp> we have helper classes that can generate "operator OP" from "operator OP=", where "OP" can be "+", "/", ">>", etc. What about types and algorithms where the non-assignment version is easier than the assignment version? Should we have reverse helpers?
Sounds like a good idea in general. I think the naive implementation would be something like:
T& operator OP##=( T& rhs, const U& lhs ) { rhs = rhs OP lhs; return rhs; }
OTOH I can think of a different solution:
T& operator OP##=( T& rhs, const U& lhs ) { T tmp( rhs OP lhs ); using std::swap; swap( tmp, rhs ); return rhs; }
Which might be ways faster for certain classes. Which version were you thinking of? Which version offers a good balance in your opinion?
What about the naming of the new classes? Do you have something in mind?
I just thought up the basic idea, but nothing like the formats and such. You've gotten ahead of me.
Do we need to prevent the user from deriving from both forms, creating infinite loops that only show up at run-time (+ calling += calling + calling += ...)? How shall we accomplish it without to much burden, possibly breaking the code for weaker compilers?
Wouldn't this only happen if the user explicitly coded it that way (i.e. the user added the "OP from OP=" _and_ the "OP= from OP" helper classes)?
Daryle
_______________________________________________ Unsubscribe & other changes: http://lists.boost.org/mailman/listinfo.cgi/boost
