On Mon, 18 Jan 2010 15:08:56 -0500, Lars T. Kyllingstad
<pub...@kyllingen.nospamnet> wrote:
Steven Schveighoffer wrote:
I think conversion from a reference to a pointer should be available
via a cast, but I'm not sure whether the compiler should allow class
pointers. My gut feeling is no.
Isn't this already possible?
class Foo { }
Foo foo = new Foo;
Foo* ptr = cast(Foo*) foo;
// ptr is not a pointer to the reference.
assert (ptr != &foo);
Hm.. does ptr actually work though? My guess is it would not.
i.e. I think this would not work:
class Foo
{
int x;
void bar() { writefln(x); }
}
Foo foo = new Foo;
foo.x = 42;
Foo* ptr = cast(Foo*) foo;
ptr.bar(); // I predict at least that it does not print 42, possibly it's
a crash.
The reason is because Foo* means "a pointer to a reference to a Foo."
This is the whole problem with builtin references, you can't get at the
type without including the reference.
Are there any syntax ambiguities here? & is also a binary op, but then
again, so is *. Will there be an issue with && ? I mean, because the
references are rebindable, you should be able to have a reference to a
reference.
Also, struct references in this way will be usable in safe D, enabling
heap struct data!
The more I think about it, the more I like having an explicit
reference denotation for classes, with the compiler enforcing that you
simply can't use class data as a value type. This basically makes all
the tail-X syntax just work, and still retains the benefits of classes
being reference-only types. The tail shared problem is a really crappy
issue, worse than tail-const.
I like it too. :) But I'm not sure we should use the & symbol:
Foo& foo = new Foo; // & denotes a reference
Bar* bar = &barValue; // & returns a pointer
Yes, C++ does it, but it's still ugly.
C++ is quite different, C++ uses & to denote the same thing as ref does in
D, except you can declare them wherever, not just in parameter lists.
i.e.:
Foo foo, other;
Foo& foo2 = foo; // one and only time you can bind foo2
foo2 = other; // equivalent to saying foo = other, does not rebind foo2.
Foo& foo3 = new Foo; // Error, new Foo returns a pointer, cannot assign to
a reference
The second line you have there is a bit troubling. I agree it doesn't
look very good. Note that we already live with * having three meanings --
denoting a pointer, dereferencing a pointer, and multiplication. In all 3
cases the syntax is unambiguous, but the meaning isn't so clear to a
person reading it. It's roughly the same as & would be. I wonder if
there are better symbols?
Foo$
Foo%
Foo#
-Steve
