On Mon, 25 Apr 2005 13:01:58 -0400, Philippe Mori <philippe_mori@hotmail.com> wrote:
You might look into the book "C++ Coding Standard" by Herb Sutter and Andrei Alexandrescu at items 27 and 55 in particular.
If operators returns const objects the many functions should probably also returns const objects.
As mentionned in the book, returning const objects disable some usefull construct on temporary objects (like calling a non-const member function) and might break some existing client code.
So for consistency, I think that boost operators should returns non-const objects as most librairies do (including probably the STL for complex numbers).
Well, according to my guru, that is not how things are supposed to work. See Scott Meyers' "Effective C++" 2nd Edition, page 91. His main point is that user-defined types should behave like the built-in types - meaning that a construct like (a * b) = c; should be illegal, whether a,b, and c are integers, floats or user-defined. So, for consistency, I think that boost operators should return const objects. More generally, he writes (same page): "Having a function return a constant value often makes it possible to reduce the incidence of client errors without giving up safety or efficiency". So yes, I think you are right, many (most) functions should also return const objects. I suppose, though, that there may be situations where it may be of interest to call a non-const member function on a temporary object, although this sounds a bit like sloppy programming to me. In terms of operators.hpp, however, this is rarely the case, as the binary operators are declared inline, meaning that the return values in most cases are constructed right in the target variables. Therefore I think that e.g. x=(a+b).somenonconstfunction(); will rarely be faster than UserType y=a+b; x=y.somenonconstfunction(); You are right about the complex numbers in the STL. And this, of course, makes programming constructs like complex<float> x=((a*b)+=c); possible. But because the complex operators * and + are declared inline, there is no reason to think that this is faster than complex<float> x=(a*b)+c; only harder to read, and non-compatible with built-in types. And it is never faster than complex<float> x=(a*b); x+=c; I do not see any realistic uses of the non-const return values from the binary operators in complex.h. Can you give me an example? And more importantly, are there boost libraries or client libraries that depend on the non-const-ness of the binary operator results in operators.hpp? --- Søren