www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - null in D

reply bearophile <bearophileHUGS lycos.com> writes:
This is the C FAQ:
ftp://ftp.eskimo.com/u/s/scs/C-faq/faq.gz
at the point 5.2: it says:

an argument being passed to a function is not necessarily recognizable as a
pointer context, and the compiler may not be able to tell that an unadorned 0
"means" a null pointer.  To generate a null pointer in a function call context,
an explicit cast may be required<

So essentially in C this is the right thing to call foo() that takes a pointer to int (using 0 instead of NULL is the same): foo((int *)NULL); So in D is this better, like in C: foo((int *)null); Or is this always enough in D? foo(null); Bye, bearophile
Aug 19 2008
parent reply "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"bearophile" wrote
 This is the C FAQ:
 ftp://ftp.eskimo.com/u/s/scs/C-faq/faq.gz
 at the point 5.2: it says:

an argument being passed to a function is not necessarily recognizable as 
a pointer context, and the compiler may not be able to tell that an 
unadorned 0 "means" a null pointer.  To generate a null pointer in a 
function call context, an explicit cast may be required<

So essentially in C this is the right thing to call foo() that takes a pointer to int (using 0 instead of NULL is the same): foo((int *)NULL); So in D is this better, like in C: foo((int *)null); Or is this always enough in D? foo(null);

I would expect this probably is a side effect of 1) that NULL is not part of the language, and 2) some C standard libraries define NULL as 0. Some define NULL as (void*)0, which probably don't have this problem. I expect in D that since null is a first-class keyword, and not some alias or definition, its usage is understood correctly by the compiler to always be a pointer or null reference. That being said, overloaded functions which have 2 versions which take different reference types must be selected by using a cast. For example: foo(int *i) {...} foo(char *c) {...} foo(null); // which one to call? -Steve
Aug 19 2008
parent reply bearophile <bearophileHUGS lycos.com> writes:
Steven Schveighoffer:
 I would expect this probably is a side effect of 1) that NULL is not part of 
 the language, and 2) some C standard libraries define NULL as 0.  Some 
 define NULL as (void*)0, which probably don't have this problem.

Well, what you say here is generally not precise/almost wrong regarding C; that FAQ explains how things are. And NULL defined as (void*)0 can't solve that problem, it seems. I did suppose to know enough C before reading that FAQ ;-)
 I expect in D that since null is a first-class keyword, and not some alias 
 or definition, its usage is understood correctly by the compiler to always 
 be a pointer or null reference.

I expect it too, but I'd like to be sure :-)
 That being said, overloaded functions which have 2 versions which take 
 different reference types must be selected by using a cast.

I agree. Bye and thank you, bearophile
Aug 19 2008
parent "Steven Schveighoffer" <schveiguy yahoo.com> writes:
"bearophile" wrote
 Steven Schveighoffer:
 I would expect this probably is a side effect of 1) that NULL is not part 
 of
 the language, and 2) some C standard libraries define NULL as 0.  Some
 define NULL as (void*)0, which probably don't have this problem.

Well, what you say here is generally not precise/almost wrong regarding C; that FAQ explains how things are. And NULL defined as (void*)0 can't solve that problem, it seems. I did suppose to know enough C before reading that FAQ ;-)

OK, I just read that section of the FAQ and also on the NULL definition. I'll update my statement. It is not required to use a cast to qualify an unadorned NULL as long as the definition of NULL is (void *)0. This qualification tells the compiler that the 0 is not an integer (whose size is implementation dependent, and might not be of pointer-size), but is in fact a full pointer-sized zero. If NULL is defined as simply 0, then a qualification is necessary in some circumstances. It appears that the only place this is an issue is for unprototyped functions and for variadic functions. The gist of it is, you are declaring a type for the 0, not just assuming the compiler is assigning the correct type.
 I expect in D that since null is a first-class keyword, and not some 
 alias
 or definition, its usage is understood correctly by the compiler to 
 always
 be a pointer or null reference.

I expect it too, but I'd like to be sure :-)

You can be sure :) null is always typed as a pointer, which means it should always be passed as a pointer-sized value. The two cases I can think of where a cast is necessary are for when you wish to pass a typed null pointer to a D variadic function (to allow D to declare the correct type), or when you have overloads of pointer-typed arguments and you want to pass null. However, the problems that are associated with C, in that it doesn't pass the right amount of data to a function, cannot happen with D. -Steve
Aug 19 2008