🚀 go-pugleaf

In article <1992Aug22.011400.14896@sunb10.cs.uiuc.edu> pjl@sparc6.cs.uiuc.edu (Paul Lucas) writes:

> 	The example I gave was the member-function:

> 		void Link::DeleteAll() {
> 			for ( Link *p = this, *q; p; p = q ) {
> 				q = p->next;
> 				delete p;
> 			}
> 		}

Because this example ultimately says `delete this' (because p == this
and it says `delete p'), I am already tempted to dismiss it out of hand.
I think it's a Bad Idea to write member functions that invalidate their
object, because it is so far away from what lots of people will expect.

Putting that aside, though, I don't see why it's any harder to make DeleteAll
a static member function with an explicit pointer argument:

	/* static */ void Link::DeleteAll(Link* p) {
		for (Link* q; p; p = q) {
			q = p->next;
			delete p;
		}
	}

The code is about the same length; the only difference in use is that
instead of saying

	foo->DeleteAll();

you say

	Link::DeleteAll(foo);

So I don't think this example is a particularly telling argument.

Ditto for the next example (omitted for brevity).

> 	Again, to reiterate (for Andrew's sake), I think it's a
> 	zero-cost feature; code that works now will continue to work,

It is not a zero-cost feature, because it would require compilers to
generate extra code for every call of a member function inherited
from a base class in the presence of virtual inheritance.

> 	and programmers who ignore it will be unaffected, i.e., if they
> 	don't check 'this' their programs will exhibit undefined
> 	behavior (by trying to access members) and "undefined behavior"
> 	is what happens now anyway.

The feature would prohibit C++ implementations from detecting this==0
as an error, which would make at least some genuine mistakes harder to find.


-- 
				--Andrew Koenig
				  ark@europa.att.com