Null references redux

Jeremie Pelletier jeremiep at gmail.com
Sat Sep 26 22:31:58 PDT 2009


Christopher Wright wrote:
> Jeremie Pelletier wrote:
>> What if using 'Object obj;' raises a warning "unitialized variable" 
>> and makes everyone wanting non-null references happy, and 'Object obj 
>> = null;' raises no warning and makes everyone wanting to keep the 
>> current system (all two of us!) happy.
>>
>> I believe it's a fair compromise.
> 
> It's a large improvement, but only for local variables. If your segfault 
> has to do with a local variable, unless your function is monstrously 
> large, it should be easy to fix, without changing the type system.
> 
> The larger use case is when you have an aggregate member that cannot be 
> null. This can be solved via contracts, but they are tedious to write 
> and ubiquitous.

But how would you enforce a nonnull type over an aggregate in the first 
place? If you can, you could also apply the same initializer semantics I 
suggested earlier.

Look at this for example:

struct A {
	Object cannotBeNull;
}

void main() {
	A* a = new A;
}

Memory gets initialized to zero, and you have a broken non-null type. 
You could have the compiler throw an error here, but the compiler cannot 
possibly know about all data creation methods such as malloc, calloc or 
any other external allocator.

You could even do something like:

Object* foo = calloc(Object.sizeof);

and the compiler would let you dereference foo resulting in yet another 
broken nonnull variable.

Non-nulls are a cute idea when you have a type system that is much 
stricter than D's, but there are just way too many workarounds to make 
it crash in D.



More information about the Digitalmars-d mailing list