🚀 go-pugleaf

> ==========Fergus Henderson, 1/26/96==========
 
[stuff deleted]
 
> David Byrden <100101.2547@compuserve.com> writes:
 
 [...]

> >Operator.() was not overloaded because you can achieve exactly
> this same 
> >effect without it,
 
> Perhaps you can in this particular case...
 
> >if the clas Handle has a set of member functions matching those
> in Bitmap,
 
> .... but only with a lot of tedious programming.  Furthermore,
all those
> forwarding functions are a maintenance problem; every time you add
> a new function to Bitmap, you need to remember to add one to Handle.
 
> Now, please tell me how to write a template smart reference
class without
> using operator.()?  Can I attain that effect "with a little programming
> using existing facilities"?  I think not.

Now that this discussion has gone far enough to convince
me that there is real merit to this, and that extensively
discussed never implies that it is wisely decided, I have
some pragmatic questions.

Does the draft explicitly exclude what it does not require?
In this case, that means does the draft preclude compilers
from allowing this, possibly as an option?  Or can compilers
provide more extensive capabilities, possibly with enabling
flags, than the draft specifies?  Note that doing that will be
part of looking at later extensions which will have to happen
in the lull after the standardizing storm.  I hope that it is
possible as an optional extension (that is likely to become
a defacto addition in real use).

We MUST look beyond the current standardization wall
that is putting a BIG ripple in the evolution of the language.
As a user, I certainly take that perspective and try very
hard to represent it here.

Good Day
Dick
Dick.Menninger@DaytonOH.ATTGIS.COM
---
[ comp.std.c++ is moderated.  Submission address: std-c++@ncar.ucar.edu.
  Contact address: std-c++-request@ncar.ucar.edu.  The moderation policy
  is summarized in http://dogbert.lbl.gov/~matt/std-c++/policy.html. ]