Comments for Well, technically...

Comment on Exponent operator overloading by Andy Balaam

Andy Balaam — Sat, 02 Jan 2010 17:33:40 +0000

Convert to exponent, then apply exponent. It kind of makes sense.

I vote for more operator overloading evil.

Comment on Implementation of operator+ by Andy Balaam

Andy Balaam — Tue, 19 May 2009 10:43:05 +0000

Or rather, miss the lack of an &.

Comment on Implementation of operator+ by Andy Balaam

Andy Balaam — Tue, 19 May 2009 10:42:49 +0000

I must say I much prefer Take 3 over the original implementation, just for its clarity (to me). I could easily miss an & and be confused.

Comment on Dependent bases, virtual functions, what does this call? by Andy Balaam

Andy Balaam — Tue, 21 Apr 2009 10:42:30 +0000

I could live with it if it were everywhere. It is the inconsistency that hurts me.

Python requires ’self.’, which is fine. Nice and explicit.

Comment on Dependent bases, virtual functions, what does this call? by hashpling

hashpling — Tue, 21 Apr 2009 10:39:48 +0000

In which case you have a different set of problems and a diktat of ‘never use this->’ is an acceptable stance as the chances of them being in a situation where ‘this->’ is required and not understanding that the diktat can and should be ignored is vanishingly small. (Assuming that, like me, you are against unnecessary ‘this->’ which is often a sign of over-reliance on so-called ‘intellisense’.)

Comment on Dependent bases, virtual functions, what does this call? by Andy Balaam

Andy Balaam — Tue, 21 Apr 2009 10:27:40 +0000

They always look blank.

Comment on Dependent bases, virtual functions, what does this call? by hashpling

hashpling — Thu, 16 Apr 2009 18:47:41 +0000

Just ask them if they are accessing a member of a dependent base via an otherwise non-dependent expression. If they look blank, then it’s your queue to shout: “so why are you using ‘this->’?”.

I made this point on a SO question, but it’s so low down that no-one’s even bothered to downvote it.

Comment on Dependent bases, virtual functions, what does this call? by Andy Balaam

Andy Balaam — Thu, 16 Apr 2009 09:08:14 +0000

So now I have to check very carefully before berating my colleagues for writing this->f() rather than just f().

Comment on Address Space Monitor 0.6 Release by Mark

Mark — Mon, 09 Mar 2009 15:47:24 +0000

Hey,

Just wanted to thank you for this utterly awesome thing. I’ve been casting about in the dark for days looking for an obscure bug, and have now seen the light thanks to Address Space Monitor. Being able to see the address space usage immediately put me on the right track. Wonderful!

Thanks,
Mark

Comment on Pass by reference, return by value, etc by hashpling

hashpling — Tue, 27 Jan 2009 22:27:25 +0000

For the example that I’m looking at, I’m really thinking of the non-inline operator+= as the function of real value. The inline operator+ is an inline helper function to allow the example class to be used more flexibly.

The operator+ implementation is essentially providing client code as efficient a recipe as possible for using operator+= automatically in addition expressions. I don’t really have any problems with slightly different signatures so long as they don’t introduce any semantic gotchas.

As for slicing, because operator+ creates a new object, it’s only really fully applicable to types with value semantics. For this reason I don’t really consider slicing a particular issue.

Consider the following.

class Derived : public Base { /* … */ }

Base operator+( const Base& l, const Base& r ) { /* … */ }

Whatever the details of the implementation, if there is no operator+ defined for Derived types, then the expression d1 + d2 will take two values of derived types and return a result whose complete type is just Base. Conceptually, the answer is sliced from what it could (should?) have been, even if neither parameter has been sliced in and of itself.

My preferred method of eliminating slicing concerns is to keep base classes abstract and to only implement free operator implementations for the most derived concrete classes.