Difference between '\0' and NULL

[lak]

What is the difference b/w '\0' and NULL?
In which case It is useful?

[santosh]

In article
<fd**********************************@d27g2000prf. googlegroups.com>,
lak <la********@gmail.comwrote on Monday 26 Nov 2007 2:40 pm:

What is the difference b/w '\0' and NULL?

The first is the representation for the null character, i.e., a
character with value zero. It is used as a string terminator in C.
It is actually an "escape sequence" with an octal zero.

The second is a macro that resolves to a null pointer value. In C source
code a literal zero is also converted into a null pointer constant when
it occurs in a pointer context.

The first expression is of type int while the second is of a pointer
type.

In which case It is useful?

Use '\0' to terminate strings and NULL to initialise pointers and set
them to a "safe" value after they have been used.

Please browse the comp.lang.c FAQ:

<http://c-faq.com/>

[Richard Bos]

santosh <sa*********@gmail.comwrote:

lak <la********@gmail.comwrote on Monday 26 Nov 2007 2:40 pm:

What is the difference b/w '\0' and NULL?

The first is the representation for the null character, i.e., a
character with value zero. It is used as a string terminator in C.
It is actually an "escape sequence" with an octal zero.

The second is a macro that resolves to a null pointer value. In C source
code a literal zero is also converted into a null pointer constant when
it occurs in a pointer context.

The first expression is of type int while the second is of a pointer
type.

Subtly wrong. NULL is a null pointer constant, which is either an
integer constant with value zero, or such a constant cast to void *. In
the second case it has pointer type, but in the first case it has
integer type. In fact, confusingly, '\0' is a legal (but unwise)
spelling for a null pointer constant.

Richard

[Kenneth Brody]

Richard Bos wrote:

>
santosh <sa*********@gmail.comwrote:

lak <la********@gmail.comwrote on Monday 26 Nov 2007 2:40 pm:

What is the difference b/w '\0' and NULL?

The first is the representation for the null character, i.e., a
character with value zero. It is used as a string terminator in C.
It is actually an "escape sequence" with an octal zero.

The second is a macro that resolves to a null pointer value. In C source
code a literal zero is also converted into a null pointer constant when
it occurs in a pointer context.

The first expression is of type int while the second is of a pointer
type.

Subtly wrong. NULL is a null pointer constant, which is either an
integer constant with value zero, or such a constant cast to void *. In
the second case it has pointer type, but in the first case it has
integer type. In fact, confusingly, '\0' is a legal (but unwise)
spelling for a null pointer constant.

While this is valid:

void *ptr = '\0';

the following will most likely fail (or at least give a warning):

int i = NULL;

Yes, the standard allows NULL to be an "integer constant with value
zero" (such as "#define NULL 0"), but it is more likely defined as
a value cast to void * (as in "#define NULL ((void *)0)"), simply
because it's "safer". (In fact, it's probably required in an
implementation where int and void* are represented differently.
Consider the consequences of passing VOID to a varadic function.)

--
+-------------------------+--------------------+-----------------------+
| Kenneth J. Brody | www.hvcomputer.com | #include |
| kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer.h|
+-------------------------+--------------------+-----------------------+
Don't e-mail me at: <mailto:Th*************@gmail.com>

[Flash Gordon]

Kenneth Brody wrote, On 26/11/07 18:19:

Richard Bos wrote:

>santosh <sa*********@gmail.comwrote:

>>lak <la********@gmail.comwrote on Monday 26 Nov 2007 2:40 pm:

What is the difference b/w '\0' and NULL?
The first is the representation for the null character, i.e., a
character with value zero. It is used as a string terminator in C.
It is actually an "escape sequence" with an octal zero.

The second is a macro that resolves to a null pointer value. In C source
code a literal zero is also converted into a null pointer constant when
it occurs in a pointer context.

The first expression is of type int while the second is of a pointer
type.

Subtly wrong. NULL is a null pointer constant, which is either an
integer constant with value zero, or such a constant cast to void *. In
the second case it has pointer type, but in the first case it has
integer type. In fact, confusingly, '\0' is a legal (but unwise)
spelling for a null pointer constant.

While this is valid:

void *ptr = '\0';

the following will most likely fail (or at least give a warning):

int i = NULL;

Yes, the standard allows NULL to be an "integer constant with value
zero" (such as "#define NULL 0"), but it is more likely defined as
a value cast to void * (as in "#define NULL ((void *)0)"), simply
because it's "safer".

It definitely makes sense for this to be done, although I'm sure one of
the implementations I've used in the past few years did not do it.

(In fact, it's probably required in an
implementation where int and void* are represented differently.

No, this is definitely not true. A conforming implementation can use
"#define NULL 0" irrespective of the relative sizes and representations.

Consider the consequences of passing VOID to a varadic function.)

Assuming you mean passing a null pointer to a varidac function, yes that
is a problem and one of the few instances where you need a cast.
--
Flash Gordon

[=?UTF-8?q?Harald_van_D=C4=B3k?=]

On Mon, 26 Nov 2007 13:19:34 -0500, Kenneth Brody wrote:

(In fact, it's probably required in an implementation
where int and void* are represented differently.

It's not.

Consider the
consequences of passing VOID to a varadic function.)

Passing NULL to a variadic function is a bad idea, not only for that
reason, but also because the function probably expects a specific pointer
type other than void *.

[Kenneth Brody]

Flash Gordon wrote:

>
Kenneth Brody wrote, On 26/11/07 18:19:

[...]

Yes, the standard allows NULL to be an "integer constant with value
zero" (such as "#define NULL 0"), but it is more likely defined as
a value cast to void * (as in "#define NULL ((void *)0)"), simply
because it's "safer".

It definitely makes sense for this to be done, although I'm sure one of
the implementations I've used in the past few years did not do it.

(In fact, it's probably required in an
implementation where int and void* are represented differently.

No, this is definitely not true. A conforming implementation can use
"#define NULL 0" irrespective of the relative sizes and representations.

Consider the consequences of passing VOID to a varadic function.)

D'oh... s/VOID/NULL/

Assuming you mean passing a null pointer to a varidac function, yes that
is a problem and one of the few instances where you need a cast.

Would you really need to pass "(void *)NULL"? Ewww.

Yes, the standard as-written probably requires it. I wonder if they
meant that to be the case?

--
+-------------------------+--------------------+-----------------------+
| Kenneth J. Brody | www.hvcomputer.com | #include |
| kenbrody/at\spamcop.net | www.fptech.com | <std_disclaimer.h|
+-------------------------+--------------------+-----------------------+
Don't e-mail me at: <mailto:Th*************@gmail.com>

[Flash Gordon]

Kenneth Brody wrote, On 26/11/07 20:40:

Flash Gordon wrote:

>Kenneth Brody wrote, On 26/11/07 18:19:

<snip possible NULL definitions>

>Assuming you mean passing a null pointer to a varidac function, yes that
is a problem and one of the few instances where you need a cast.

Would you really need to pass "(void *)NULL"? Ewww.

Yes, the standard as-written probably requires it. I wonder if they
meant that to be the case?

I might pass (void*)0 instead. I know someone who provides a macro
called NP, but the code in question pre-dates when you could rely on
having an ANSI C compiler.
--
Flash Gordon

[Spoon]

Kenneth Brody wrote:

Would you really need to pass "(void *)NULL"? Ewww.

cf. http://c-faq.com/~scs/cgi-bin/faqcat.cgi?sec=null

specifically http://c-faq.com/null/nullreq.html