Velocity Reviews - Computer Hardware Reviews

Velocity Reviews > Newsgroups > Programming > C Programming > strange integer-pointer behaviour

Reply
Thread Tools

strange integer-pointer behaviour

 
 
matevzb
Guest
Posts: n/a
 
      08-13-2007
I've ran into some fishy code that, at first glance, is buggy, but it
seems to work correctly
and none of the compilers I've tried (five so far, on various systems)
gives any warnings.
The code:
============================
#include <stdio.h>

void
fcn (char *str)
{
if (str == '\0')
{
printf ("str!\n");
}
}

int
main (void)
{
fcn ('\0');
return 0;
}
============================
My understanding so far: '\0' is passed to fcn(), it equals integer 0,
which in turn "equals"
a NULL pointer in terms of zero-ness. The 0 in fcn() is then compared
to '\0' which is also a 0.
No warnings, no errors, code works (or so it seems).
But - if I pass e.g. '\1' to fcn() than all the compilers complain
with similar warnings,
i.e. making a pointer from integer without a cast.

My question is, why don't the compilers complain when '\0' is passed?
Shouldn't they give
the same warning, as it's also an integer (albeit 0 in value)?

--
WYCIWYG - what you C is what you get

 
Reply With Quote
 
 
 
 
Eric Sosman
Guest
Posts: n/a
 
      08-13-2007
matevzb wrote On 08/13/07 13:35,:
> I've ran into some fishy code that, at first glance, is buggy, but it
> seems to work correctly
> and none of the compilers I've tried (five so far, on various systems)
> gives any warnings.
> The code:
> ============================
> #include <stdio.h>
>
> void
> fcn (char *str)
> {
> if (str == '\0')
> {
> printf ("str!\n");
> }
> }
>
> int
> main (void)
> {
> fcn ('\0');
> return 0;
> }
> ============================
> My understanding so far: '\0' is passed to fcn(), it equals integer 0,
> which in turn "equals"
> a NULL pointer in terms of zero-ness. The 0 in fcn() is then compared
> to '\0' which is also a 0.
> No warnings, no errors, code works (or so it seems).
> But - if I pass e.g. '\1' to fcn() than all the compilers complain
> with similar warnings,
> i.e. making a pointer from integer without a cast.
>
> My question is, why don't the compilers complain when '\0' is passed?
> Shouldn't they give
> the same warning, as it's also an integer (albeit 0 in value)?


A literal constant zero[*] used in a pointer context
*is* a null pointer constant. In the code above, '\0'
is just a decorative way to write a literal constant zero.
The compiler sees that it's being used where a pointer is
expected, so the compiler recognizes the zero as a null
pointer constant instead of as an integer. Indeed, you
will find that on many systems the NULL macro is defined
as an unadorned zero.
[*] Any zero-valued constant integer expression will
do; try `fcn (42 / 100)', for example. Also, the
expression is still a null pointer constant if it
is cast to `void*'.

This special treatment applies only to

- Zero-valued expressions: If the expression's value
is non-zero, the expression cannot be a null pointer
constant. That's why the compiler complained when
you tried to use '\1' as an argument to fcn().

- Integer-valued expressions: If the expression's type
is `double' or `float' or `struct fubar', it is not
a null pointer constant. fcn(0.0) won't work.

- Constant expressions: If the expression is not a
compile-time constant, it is not a null pointer
constant. fcn(x - x) won't work; you can deduce
that the argument will always be zero, but from
the compiler's point of view it's just a remarkable
coincidence.

The FAQ has a section devoted to null pointers; you
might find it helpful.

--
http://www.velocityreviews.com/forums/(E-Mail Removed)
 
Reply With Quote
 
 
 
 
matevzb
Guest
Posts: n/a
 
      08-13-2007
On Aug 13, 7:58 pm, Eric Sosman <(E-Mail Removed)> wrote:
> A literal constant zero[*] used in a pointer context
> *is* a null pointer constant. In the code above, '\0'
> is just a decorative way to write a literal constant zero.
> The compiler sees that it's being used where a pointer is
> expected, so the compiler recognizes the zero as a null
> pointer constant instead of as an integer. Indeed, you
> will find that on many systems the NULL macro is defined
> as an unadorned zero.

Yes, sorry about even posting this. Moments after I posted, I realized
that all bets are off with 0 with regards to (pointer) type
checking...
Thanks

--
WYCIWYG - what you C is what you get

 
Reply With Quote
 
Eric Sosman
Guest
Posts: n/a
 
      08-13-2007
matevzb wrote On 08/13/07 14:30,:
> On Aug 13, 7:58 pm, Eric Sosman <(E-Mail Removed)> wrote:
>
>> A literal constant zero[*] used in a pointer context
>>*is* a null pointer constant. In the code above, '\0'
>>is just a decorative way to write a literal constant zero.
>>The compiler sees that it's being used where a pointer is
>>expected, so the compiler recognizes the zero as a null
>>pointer constant instead of as an integer. Indeed, you
>>will find that on many systems the NULL macro is defined
>>as an unadorned zero.

>
> Yes, sorry about even posting this. Moments after I posted, I realized
> that all bets are off with 0 with regards to (pointer) type
> checking...


Well, no, not exactly. There is no need to type-check
a NULL, because NULL is a perfectly good value for any kind
of pointer at all. The confusion (what remains of it) comes
from the fact that there are many ways to spell NULL.

Gertrude Stein never said "A NULL is a '\0' is a 0,"
but she could have.

--
(E-Mail Removed)
 
Reply With Quote
 
CBFalconer
Guest
Posts: n/a
 
      08-13-2007
matevzb wrote:
>
> I've ran into some fishy code that, at first glance, is buggy, but
> it seems to work correctly and none of the compilers I've tried
> (five so far, on various systems) gives any warnings. The code:
>
> #include <stdio.h>
>
> void fcn (char *str) {


This wants a pointer to char as the parameter.

> if (str == '\0') {


This tests the parameter against a fixed char.

> printf ("str!\n");
> }
> }
>
> int main (void) {
> fcn ('\0');


This passes an integer (char representation) to something that
wants a char. pointer.

> return 0;
> }


--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>



--
Posted via a free Usenet account from http://www.teranews.com

 
Reply With Quote
 
Keith Thompson
Guest
Posts: n/a
 
      08-13-2007
Eric Sosman <(E-Mail Removed)> writes:
> matevzb wrote On 08/13/07 14:30,:
>> On Aug 13, 7:58 pm, Eric Sosman <(E-Mail Removed)> wrote:
>>> A literal constant zero[*] used in a pointer context
>>>*is* a null pointer constant. In the code above, '\0'
>>>is just a decorative way to write a literal constant zero.
>>>The compiler sees that it's being used where a pointer is
>>>expected, so the compiler recognizes the zero as a null
>>>pointer constant instead of as an integer. Indeed, you
>>>will find that on many systems the NULL macro is defined
>>>as an unadorned zero.

>>
>> Yes, sorry about even posting this. Moments after I posted, I realized
>> that all bets are off with 0 with regards to (pointer) type
>> checking...

>
> Well, no, not exactly. There is no need to type-check
> a NULL, because NULL is a perfectly good value for any kind
> of pointer at all. The confusion (what remains of it) comes
> from the fact that there are many ways to spell NULL.
>
> Gertrude Stein never said "A NULL is a '\0' is a 0,"
> but she could have.


On the other hand, I'd like my compiler to warn me about using '\0' as
a null pointer constant, at least optionally. It's perfectly legal,
but it usually indicates a conceptual error on the part of the
programmer.

--
Keith Thompson (The_Other_Keith) (E-Mail Removed) <http://www.ghoti.net/~kst>
San Diego Supercomputer Center <*> <http://users.sdsc.edu/~kst>
"We must do something. This is something. Therefore, we must do this."
-- Antony Jay and Jonathan Lynn, "Yes Minister"
 
Reply With Quote
 
Default User
Guest
Posts: n/a
 
      08-13-2007
Eric Sosman wrote:

> matevzb wrote On 08/13/07 14:30,:


> > Yes, sorry about even posting this. Moments after I posted, I
> > realized that all bets are off with 0 with regards to (pointer) type
> > checking...

>
> Well, no, not exactly. There is no need to type-check
> a NULL, because NULL is a perfectly good value for any kind
> of pointer at all. The confusion (what remains of it) comes
> from the fact that there are many ways to spell NULL.
>
> Gertrude Stein never said "A NULL is a '\0' is a 0,"
> but she could have.


Well, her code was notoriously buggy anyway.




Brian

 
Reply With Quote
 
CBFalconer
Guest
Posts: n/a
 
      08-14-2007
Eric Sosman wrote:
>

.... snip ...
>
> Well, no, not exactly. There is no need to type-check
> a NULL, because NULL is a perfectly good value for any kind
> of pointer at all. The confusion (what remains of it) comes
> from the fact that there are many ways to spell NULL.
>
> Gertrude Stein never said "A NULL is a '\0' is a 0,"
> but she could have.


I don't agree that '\0' is a spelling of NULL. It is a spelling of
the int value zero. The primes make it precisely an int.

--
Chuck F (cbfalconer at maineline dot net)
Available for consulting/temporary embedded and systems.
<http://cbfalconer.home.att.net>



--
Posted via a free Usenet account from http://www.teranews.com

 
Reply With Quote
 
somenath
Guest
Posts: n/a
 
      08-14-2007
> - Constant expressions: If the expression is not a
> compile-time constant, it is not a null pointer
> constant. fcn(x - x) won't work; you can deduce
> that the argument will always be zero, but from
> the compiler's point of view it's just a remarkable
> coincidence.
>


But I compiled the following code using "gcc -Wall " options.It does
not throw even warning .
#include <stdio.h>

void
fcn (char *str)
{
if (str == NULL)
{
printf ("str!\n");
}



}


int
main (void)
{
int x;
fcn (x - x);
return 0;

}

 
Reply With Quote
 
Eric Sosman
Guest
Posts: n/a
 
      08-14-2007
somenath wrote On 08/14/07 10:26,:
>> - Constant expressions: If the expression is not a
>> compile-time constant, it is not a null pointer
>> constant. fcn(x - x) won't work; you can deduce
>> that the argument will always be zero, but from
>> the compiler's point of view it's just a remarkable
>> coincidence.
>>

>
>
> But I compiled the following code using "gcc -Wall " options.It does
> not throw even warning .
> #include <stdio.h>
>
> void
> fcn (char *str)
> {
> if (str == NULL)
> {
> printf ("str!\n");
> }
>
>
>
> }
>
>
> int
> main (void)
> {
> int x;
> fcn (x - x);
> return 0;
>
> }


<off-topic>

Try "-Wall -W -O2" or even "-Wall -W -ansi -pedantic -O2".
Despite its inclusive-sounding name, "-Wall" does not enable
all of the warnings gcc can generate.

</off-topic>

As for the `x - x', the Standard says (6.3.2.3p3):

An integer constant expression with the value 0,
or such an expression cast to type void *, is called
a _null pointer constant._ If a null pointer constant
is converted to a pointer type, the resulting pointer,
called a _null pointer,_ is guaranteed to compare
unequal to a pointer to any object or function.

The question of whether `x - x' is a null pointer constant
thus hinges on whether it is an integer constant expression.
The Standard defines I.C.E. in 6.6p6:

An _integer constant expression_ shall have integer
type and shall only have operands that are integer
constants, enumeration constants, character constants,
sizeof expressions whose results are integer constants,
and floating constants that are the immediate operands
of casts. [...]

Since `x - x' has operands that are impermissible in an
I.C.E., `x - x' is not an I.C.E. and hence not an N.P.C.

--
(E-Mail Removed)

 
Reply With Quote
 
 
 
Reply

Thread Tools

Posting Rules
You may not post new threads
You may not post replies
You may not post attachments
You may not edit your posts

BB code is On
Smilies are On
[IMG] code is On
HTML code is Off
Trackbacks are On
Pingbacks are On
Refbacks are Off


Similar Threads
Thread Thread Starter Forum Replies Last Post
debugger behaviour different to execution behaviour Andy Chambers Java 1 05-14-2007 09:51 AM
a strange behaviour of FF Maurice Firefox 2 03-11-2005 11:53 PM
Strange mouse behaviour with flash in Mozilla 1.3.7 hpoppe Firefox 0 11-07-2004 12:16 PM
Strange taskbar behaviour (notification area) Falcon Wireless Networking 0 08-17-2004 09:03 AM
[mozilla1.6] strange behaviour with newsgroup joost68 Firefox 5 04-03-2004 03:48 AM



Advertisments