NULL: Is it guaranteed to evaluate 'not true'

[Mark A. Odell]

Is NULL guaranteed to evaluate 'not true', e.g. is it completely safe and
portable to write:

char *pFoo = malloc(1024);
if (pFoo)
{
/* use pFoo
*/
free(pFoo);
}

Or must I check against NULL explicitly as in:

if (pFoo != NULL) ...

Thanks.

--
- Mark ->
--

[Joona I Palaste]

Mark A. Odell <no****@embedde dfw.com> scribbled the following:

Is NULL guaranteed to evaluate 'not true', e.g. is it completely safe and
portable to write: char *pFoo = malloc(1024);
if (pFoo)
{
/* use pFoo
*/
free(pFoo);
}

AFAIK it's indeed guaranteed to evaluate as "not true". Some C expert
will probably offer a more qualified opinion here.

--
/-- Joona Palaste (pa*****@cc.hel sinki.fi) ---------------------------\
| Kingpriest of "The Flying Lemon Tree" G++ FR FW+ M- #108 D+ ADA N+++|
| http://www.helsinki.fi/~palaste W++ B OP+ |
\----------------------------------------- Finland rules! ------------/
"This isn't right. This isn't even wrong."
- Wolfgang Pauli

[Mike Wahler]

"Mark A. Odell" <no****@embedde dfw.com> wrote in message
news:Xn******** *************** *********@130.1 33.1.4...

Is NULL guaranteed to evaluate 'not true',
Yes.
e.g. is it completely safe and
portable to write:

char *pFoo = malloc(1024);
Portable, but not safe, since you didn't check
if malloc() succeeded or failed. If it failed,
then a dereference of 'pFoo' will give undefined
behavior.
if (pFoo)
This will be true if 'pFoo' is not == NULL.
{
/* use pFoo
*/
free(pFoo);
}

Or must I check against NULL explicitly as in:

if (pFoo != NULL) ...

No, you don't have to, but many coders prefer to
explicitly compare against NULL in the interest
of clarity.

-Mike

[Mark A. Odell]

"Mike Wahler" <mk******@mkwah ler.net> wrote in
news:vb******** *********@newsr ead3.news.pas.e arthlink.net:

NULL: Is it guaranteed to evaluate 'not true'
Yes.

e.g. is it completely safe and
portable to write:

char *pFoo = malloc(1024);

Portable, but not safe, since you didn't check
if malloc() succeeded or failed.

I didn't? What's the following if (pFoo) for then? I did not dereference
pFoo until after the check if (pFoo).
If it failed,
then a dereference of 'pFoo' will give undefined
behavior.

if (pFoo)

This will be true if 'pFoo' is not == NULL.

{
/* use pFoo
*/
free(pFoo);
}

Or must I check against NULL explicitly as in:

if (pFoo != NULL) ...

No, you don't have to, but many coders prefer to
explicitly compare against NULL in the interest
of clarity.

I am certainly not one of them. I prefer C's "boolean" comparisons to
explicit values. Thanks for the reply.

--
- Mark ->
--

[Mike Wahler]

"Mark A. Odell" <no****@embedde dfw.com> wrote in message
news:Xn******** *************** *********@130.1 33.1.4...

"Mike Wahler" <mk******@mkwah ler.net> wrote in
news:vb******** *********@newsr ead3.news.pas.e arthlink.net:

NULL: Is it guaranteed to evaluate 'not true'
Yes.

e.g. is it completely safe and
portable to write:

char *pFoo = malloc(1024);

Portable, but not safe, since you didn't check
if malloc() succeeded or failed.

I didn't? What's the following if (pFoo) for then? I did not dereference
pFoo until after the check if (pFoo).

I'm still asleep it seems. :-)

If it failed,
then a dereference of 'pFoo' will give undefined
behavior.

if (pFoo)

This will be true if 'pFoo' is not == NULL.

{
/* use pFoo
*/
free(pFoo);
}

Or must I check against NULL explicitly as in:

if (pFoo != NULL) ...

No, you don't have to, but many coders prefer to
explicitly compare against NULL in the interest
of clarity.

I am certainly not one of them.

Nor am I, except when constrained by coding standards
that require it.

<I prefer C's "boolean" comparisons to explicit values.
As do I.
Thanks for the reply.

Thanks for the wake-up. :-)

-Mike

[Nick Austin]

On 25 Sep 2003 17:59:15 GMT, "Mark A. Odell" <no****@embedde dfw.com>
wrote:

Is NULL guaranteed to evaluate 'not true', e.g. is it completely safe and
portable to write:

char *pFoo = malloc(1024);
if (pFoo)
{
/* use pFoo
*/
free(pFoo);
}

Correct and entirely safe.

if() expects an integer expression, which conventionally would be
the result yielded by a relational operator such as !=. This
result will either by zero (false) or non-zero (true).

If if() is supplied with a pointer expression this causes an
implicit pointer-to-integer conversion. In this case a
non-NULL pointer is converted to a non-zero integer. The NULL
pointer is converted to zero.

Nick.

[Arthur J. O'Dwyer]

On Thu, 25 Sep 2003, Nick Austin wrote:

On 25 Sep 2003 17:59:15 GMT, "Mark A. Odell" wrote:

Is NULL guaranteed to evaluate 'not true', e.g. is it completely safe and
portable to write:

char *pFoo = malloc(1024);
if (pFoo)
Correct and entirely safe.

if() expects an integer expression,

Not true. 'if' expects to be controlled by an expression of
*scalar* type (basically, anything except an aggregate).
which conventionally would be
the result yielded by a relational operator such as !=. This
result will either by zero (false) or non-zero (true).
Sort of. 'if' compares its controlling expression to 0. If
it's not equal to 0, the body of the 'if' is executed. Otherwise,
the body of the 'if' is *not* executed. That's all.

For example,

if (foo)

is exactly equivalent to

if ((foo) != 0)

[you see now why aggregate types are not permitted in 'if'
conditions]. So, specifically,

if (pFoo)
if ((pFoo) != 0)

are equivalent expressions. And since 0 is in a pointer
context here, it's equivalent to a null pointer of type 'char *';
that is,

if (pFoo)
if ((pFoo) != NULL)
if ((pFoo) != (char*)0)

are also all equivalent. And of course they all do what you'd
expect.

If if() is supplied with a pointer expression this causes an
implicit pointer-to-integer conversion.

Nonsense. There is no "implicit pointer-to-integer conversion."
Ever. Under any circumstances. The language specifically
forbids it. The only implicit conversions are from pointers
to other pointer types, or from arrays to pointers, or between
different arithmetic types. That's it. (Unless I missed one.)

-Arthur

[Mike Wahler]

"Nick Austin" <ni**********@n ildram.co.uk> wrote in message
news:m7******** *************** *********@4ax.c om...

if() expects an integer expression, which conventionally would be
the result yielded by a relational operator such as !=. This
result will either by zero (false) or non-zero (true).

If if() is supplied with a pointer expression this causes an
implicit pointer-to-integer conversion.

This is news to me. Chapter and verse?

-Mike

[Micah Cowan]

"Mike Wahler" <mk******@mkwah ler.net> writes:

"Nick Austin" <ni**********@n ildram.co.uk> wrote in message
news:m7******** *************** *********@4ax.c om...

if() expects an integer expression, which conventionally would be
the result yielded by a relational operator such as !=. This
result will either by zero (false) or non-zero (true).

If if() is supplied with a pointer expression this causes an
implicit pointer-to-integer conversion.

This is news to me. Chapter and verse?

(To me too...)

Actually, the "implied conversion" would be integer-to-pointer,
since (according to the standard's definition), the scalar
expression will be compared with 0, requiring 0 to be converted
to NULL first.

(Naturally, by the as-if clause, no actual conversion is likely
in practice...)

-Micah

[Peter Nilsson]

"Mark A. Odell" <no****@embedde dfw.com> wrote in message news:<Xn******* *************** **********@130. 133.1.4>...

Is NULL guaranteed to evaluate 'not true',
Yes. The 'truth' of an arbitrary expressions X is determined by whether
"the expression compares unequal to 0." i.e. (X != 0).
e.g. is it completely safe and
portable to write:

char *pFoo = malloc(1024);
if (pFoo)
{
/* use pFoo
*/
free(pFoo);
}
Yes.

Or must I check against NULL explicitly as in:

if (pFoo != NULL) ...

No.

--
Peter