On Saturday, 15 September 2012 at 14:17:53 UTC, Simen Kjaeraas
wrote:
And in real code it could crash after dereferencing and before
passing to bar, if accessed (meaning that problem is in
erroneous pointer usage, not accepting ints through reference
in bar). Certainly, it is possible to break even in such
cases, as well as in other parts of the language which doesn't
necessarily mean that such parts of the language are broken.
What I was talking about is:
void bar( ref int n ) {
n = 3;
}
void main( ) {
int* p = null;
bar(p); // error
bar(null); //error
}
But that's like saying bar(int n) doesn't accept null as a
parameter - of
course it doesn't - int and int* are different types.
What I'm saying is references may be a bit safer than pointers,
but the
'guarantee' that they're not null pointers in disguise is a lie.
Again, what is the talk about? References in function parameters
or class objects? In the first case ref parameter has nothing to
do with whether was a valid object passed to function or not (as
like in your case). It only means that function works with actual
object, not a copy. Obviously, it is impossible to pass a pointer
or null when other type is expected.
If you speaking about class objects, than certainly it may
reference a valid region of memory or null (in bad and rare
cases, to random memory).
