www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Has truth of arrays always acted like this?

reply Bill Baxter <dnewsgroup billbaxter.com> writes:
I could have sworn there was a big discussion just recently about how 
"null" and "empty" were the same thing with D arrays and some people 
were arguing that should change.  But at least with the most recent D 
v1.022, it seems the truth value of uninitialized and empty arrays *are* 
different.  Has it always been that way?

Output:
a = [] (not initialized)
     if(a) -> false
     if(!a) -> true
a = [1]
     if(a) -> true
     if(!a) -> false
a = [] (cleared)
     if(a) -> true    <<== surprise! (to me)
     if(!a) -> false



Program:
//------------------------------------------
module arrayif;
import std.stdio;
void main()
{
     int[] a;
     writefln("a = %s (not initialized)", a);
     if (a) {
         writefln("    if(a) -> true");
     } else {
         writefln("    if(a) -> false");
     }
     if (!a) {
         writefln("    if(!a) -> true");
     } else {
         writefln("    if(!a) -> false");
     }

     a ~= 1;
     writefln("a = %s", a);
     if (a) {
         writefln("    if(a) -> true");
     } else {
         writefln("    if(a) -> false");
     }
     if (!a) {
         writefln("    if(!a) -> true");
     } else {
         writefln("    if(!a) -> false");
     }

     a.length = a.length-1;
     writefln("a = %s (cleared)", a);
     if (a) {
         writefln("    if(a) -> true");
     } else {
         writefln("    if(a) -> false");
     }
     if (!a) {
         writefln("    if(!a) -> true");
     } else {
         writefln("    if(!a) -> false");
     }

}
Oct 14 2007
parent reply Bill Baxter <dnewsgroup billbaxter.com> writes:
Bill Baxter wrote:

 I could have sworn there was a big discussion just recently about how 
 "null" and "empty" were the same thing with D arrays and some people 
 were arguing that should change.  But at least with the most recent D 
 v1.022, it seems the truth value of uninitialized and empty arrays *are* 
 different.  Has it always been that way?


I think maybe the discussion I was remembering was about comparison with 
null.  Indeed (a==null) is true for both uninitialized *and* length==0 
arrays.

That seems completely backwards to me.  If anything, a==null should be 
the one that checks if a has a buffer allocated at all, and if(a) should 
be the one that checks for any form of emptiness.

Barring that, they should just behave the same.

--bb
Oct 14 2007
parent reply Mike Parker <aldacron71 yahoo.com> writes:
Bill Baxter wrote:

 Bill Baxter wrote:

 I could have sworn there was a big discussion just recently about how 
 "null" and "empty" were the same thing with D arrays and some people 
 were arguing that should change.  But at least with the most recent D 
 v1.022, it seems the truth value of uninitialized and empty arrays 
 *are* different.  Has it always been that way?


 
 I think maybe the discussion I was remembering was about comparison with 
 null.  Indeed (a==null) is true for both uninitialized *and* length==0 
 arrays.
 
 That seems completely backwards to me.  If anything, a==null should be 
 the one that checks if a has a buffer allocated at all, and if(a) should 
 be the one that checks for any form of emptiness.
 
 Barring that, they should just behave the same.
 
 --bb


I recall a recent discussion specifically about empty vs. null strings, 
i.e. an empty string ("") is equivalent to a null string:

char[] s1 = "";
char[] s2 = null;

if(s1 == s2) writefln("equal");

This will evaluate to true.
Oct 14 2007
parent reply "Kris" <foo bar.com> writes:
Well, I sure hope that /never/ happens. A null is a null (the array .ptr and 
.length are both zero), while an empty string is perfectly valid.

tip: faster way (on 32bit platforms) to check for null array is to test the 
.ptr only, since it's 32 bits rather than 64.


"Mike Parker" <aldacron71 yahoo.com> wrote in message 
news:feuj8s$1kjt$1 digitalmars.com...

 Bill Baxter wrote:

 Bill Baxter wrote:

 I could have sworn there was a big discussion just recently about how 
 "null" and "empty" were the same thing with D arrays and some people 
 were arguing that should change.  But at least with the most recent D 
 v1.022, it seems the truth value of uninitialized and empty arrays *are* 
 different.  Has it always been that way?


 I think maybe the discussion I was remembering was about comparison with 
 null.  Indeed (a==null) is true for both uninitialized *and* length==0 
 arrays.

 That seems completely backwards to me.  If anything, a==null should be 
 the one that checks if a has a buffer allocated at all, and if(a) should 
 be the one that checks for any form of emptiness.

 Barring that, they should just behave the same.

 --bb


 I recall a recent discussion specifically about empty vs. null strings, 
 i.e. an empty string ("") is equivalent to a null string:

 char[] s1 = "";
 char[] s2 = null;

 if(s1 == s2) writefln("equal");

 This will evaluate to true.
Oct 14 2007
parent Bill Baxter <dnewsgroup billbaxter.com> writes:
 "Mike Parker" <aldacron71 yahoo.com> wrote in message 
 news:feuj8s$1kjt$1 digitalmars.com...

 Bill Baxter wrote:

 Bill Baxter wrote:

 I could have sworn there was a big discussion just recently about how 
 "null" and "empty" were the same thing with D arrays and some people 
 were arguing that should change.  But at least with the most recent D 
 v1.022, it seems the truth value of uninitialized and empty arrays *are* 
 different.  Has it always been that way?


 I think maybe the discussion I was remembering was about comparison with 
 null.  Indeed (a==null) is true for both uninitialized *and* length==0 
 arrays.

 That seems completely backwards to me.  If anything, a==null should be 
 the one that checks if a has a buffer allocated at all, and if(a) should 
 be the one that checks for any form of emptiness.

 Barring that, they should just behave the same.

 --bb


 I recall a recent discussion specifically about empty vs. null strings, 
 i.e. an empty string ("") is equivalent to a null string:

 char[] s1 = "";
 char[] s2 = null;

 if(s1 == s2) writefln("equal");

 This will evaluate to true. 


 


Kris wrote:

 Well, I sure hope that /never/ happens. A null is a null (the array 


.ptr and

 .length are both zero), while an empty string is perfectly valid.


Hope what never happens?


 tip: faster way (on 32bit platforms) to check for null array is to 


test the

 .ptr only, since it's 32 bits rather than 64.


size_t is 32 bits on a 32 bit platform too.

--bb
Oct 14 2007