On Wednesday, 29 August 2012 at 19:55:08 UTC, Tommi wrote:
I honestly don't know anything about memory safety and what it
entails. So, I can't comment about any of that stuff. But if
you say general ref variables can't be implemented in @safe
mode, then I can just take your word for it. But what I'm
saying is that ref variables would be a nice feature to have in
@system code.
They can be used safely if they are heap allocated (or global).
My logic is very simple: since we can use pointers in @system
code, and references are no more unsafe than pointers, then we
should be able to use references in @system code. You might
argue that references are little more than syntactic sugar (and
a bit safer) compared to pointers, but you shouldn't
underestimate the importance of syntactic sugar especially when
you're trying to lure in users of C++.
Maybe. But the scope of referencing variables should likely be
left alone. I am not sure of all the details of C++ references
either. Ref hides the fact it's a pointer/reference. This means
unless you really know what you're doing that it is not a good
thing to use.
Let's assume we compare a pointer and a ref in a struct and
copying.
struct P {
int* ptr;
}
struct R {
ref int r;
this(ref int i) {r = i;}
}
int value;
P p1, p2;
p1.ptr = value; //Compile error, not a pointer, need to use
&value
p2 = p1;
p2.ptr = 100; //compile error, need to use *p2.ptr = 100
value = 42;
R r1 = R(value)
R r2 = r1; //both reference value now
r2.r = 100; //r must be a variable if this succeeds
assert(r1.r == 42, "FAIL!");
assert(r2.r == 100, "Would succeed if it got this far");
If I have this right, as a pointer you know it's a
pointer/reference and don't make more obvious mistakes as you're
told by the compiler what's wrong. Also since it hides the fact
it's actually a pointer hidden bugs are bound to crop up more
often where reference variables were used.
If we return now r1 or r2, it silently fails since it can't
guarantee that the reference wasn't a local stack variable, or of
anything at all really. As a pointer you can blame the programmer
(It's their fault afterall), as a reference you blame the
language designer.
What would you do for the postblitz if you can't reset the
reference? Or if you could, would you do...? It would be so easy
to forget.
this(this) {
r = new int(r);
}
*Prepares for flames from Walter and Andrei*
