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
17  1828 
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.
-- Er*********@sun.com
On Aug 13, 7:58 pm, Eric Sosman <Eric.Sos...@sun.comwrote:
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
matevzb wrote On 08/13/07 14:30,:
On Aug 13, 7:58 pm, Eric Sosman <Eric.Sos...@sun.comwrote:
> 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.
-- Er*********@sun.com
Eric Sosman <Er*********@sun.comwrites:
matevzb wrote On 08/13/07 14:30,:
>On Aug 13, 7:58 pm, Eric Sosman <Eric.Sos...@sun.comwrote:
>> 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) ks***@mib.org <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"
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
- 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;
}
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.
-- Er*********@sun.com
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
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
CBFalconer <cb********@yahoo.comwrote:
Eric Sosman wrote:
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.
The only spelling of NULL, which is the name of a macro, is NULL. '\0'
is, however, a spelling of the null pointer constant.
It is a spelling of the int value zero.
No, it's an integer _constant_ of type int and value zero. Big
difference. An integer constant with value zero is a null pointer
constant; an int with value zero is not, and is not guaranteed (though
highly likely) to compare equal to a null pointer object.
Yes, I do agree that writing NULL when you mean "a null pointer
constant" is a bad idea, because it adds to the confusion many newbies
have concerning null pointers.
--
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
Fix your .sig.
Richard
CBFalconer wrote On 08/13/07 16:20,:
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.
Right.
> if (str == '\0') {
This tests the parameter against a fixed char.
No, t tests the parameter against a null pointer
constant.
> printf ("str!\n");
}
}
int main (void) {
fcn ('\0');
This passes an integer (char representation) to something that
wants a char. pointer.
No, it passes a NULL-valued `char*' to fcn(). '\0' is
a zero-valued integer constant expression, hence it is a
null pointer constant. It is used in a pointer context
(thanks to the prototype), so the N.P.C. becomes a null
pointer. The N.P. is converted to type `char*' (again,
thanks to the prototype) and that value is passed to the
function.
>
> return 0;
}
-- Er*********@sun.com
CBFalconer wrote:
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.
As others have pointed out, '\0' is an allowable null pointer constant, but
also, even in other contexts, '\0' isn't a char. It's an int. You might be
thinking of C++, where it would be a char.
> printf ("str!\n");
}
}
int main (void) {
fcn ('\0');
This passes an integer (char representation) to something that
wants a char. pointer.
As above, it passes a null pointer constant to a function expecting a
pointer argument.
> return 0;
}
On Mon, 13 Aug 2007 20:04:50 -0400, CBFalconer wrote:
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.
Nothing in the standard forbids <stddef.hor other standard
headers to #define NULL '\0'.
--
Army1987 (Replace "NOSPAM" with "email")
No-one ever won a game by resigning. -- S. Tartakower rl*@hoekstra-uitgeverij.nl (Richard Bos) writes:
CBFalconer <cb********@yahoo.comwrote:
[...]
>I don't agree that '\0' is a spelling of NULL.
The only spelling of NULL, which is the name of a macro, is NULL. '\0'
is, however, a spelling of the null pointer constant.
Of *a* null pointer constant.
>It is a spelling of the int value zero.
No, it's an integer _constant_ of type int and value zero. Big
difference. An integer constant with value zero is a null pointer
constant;
Right. More generally, so is an integer constant expression with
value zero.
an int with value zero is not, and is not guaranteed (though
highly likely) to compare equal to a null pointer object.
An "int with value zero" presumably refers to an object that exists
during execution time. A null pointer constant exists only in source
code; there's no such thing during execution.
An int with value zero cannot compare equal (or unequal) to a pointer
whose value is a null pointer. An attempt to compare them is a
constraint violation, because the types are incompatible.
It's likely, but not guaranteed, that *converting* a (non-constant)
int with value zero to a pointer type will yield a null pointer value.
Since integer-to-pointer conversion is implementation-defined, this is
actually independent of the question of whether a null pointer value
is represented as all-bits-zero.
[...]
--
Keith Thompson (The_Other_Keith) ks***@mib.org <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"
Keith Thompson <ks***@mib.orgwrote: rl*@hoekstra-uitgeverij.nl (Richard Bos) writes:
CBFalconer <cb********@yahoo.comwrote:
[...]
I don't agree that '\0' is a spelling of NULL.
The only spelling of NULL, which is the name of a macro, is NULL. '\0'
is, however, a spelling of the null pointer constant.
Of *a* null pointer constant.
_The_ spelling of _a_ null pointer constant, or _a_ spelling of _the_
null pointer constant. Take your pick; IMO, the difference is of an
angels-on-needlepoints value.
Richard rl*@hoekstra-uitgeverij.nl (Richard Bos) writes:
Keith Thompson <ks***@mib.orgwrote:
>rl*@hoekstra-uitgeverij.nl (Richard Bos) writes:
CBFalconer <cb********@yahoo.comwrote:
[...]
>I don't agree that '\0' is a spelling of NULL.
The only spelling of NULL, which is the name of a macro, is NULL. '\0'
is, however, a spelling of the null pointer constant.
Of *a* null pointer constant.
_The_ spelling of _a_ null pointer constant, or _a_ spelling of _the_
null pointer constant. Take your pick; IMO, the difference is of an
angels-on-needlepoints value.
It's not a big deal, but there isn't a single null pointer constant;
there are arbitrarily many of them.
An integer constant expression with the value 0, or such an
expression cast to type void *, is called a _null pointer
constant_.
Referring to "the null pointer constant" makes no more sense than
referring to "the integer constant". (A difference is that all null
pointer constants refer to the same value, but they're still distinct
constants.)
--
Keith Thompson (The_Other_Keith) ks***@mib.org <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"
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.
A NULL by any other name would smell as sweet to those nasal demons.
--
+-------------------------+--------------------+-----------------------+
| 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> This thread has been closed and replies have been disabled. Please start a new discussion. Similar topics
by: Bernard André |
last post by:
Hi All,
I posted this already today and I am really getting bananas with this issue:
Using Visual Basic 6.0, I am sending SMS. These SMS can be added to an
Access 2000 table by users on the...
|
by: Allcomp |
last post by:
Hello,
I have seen something really strange in VB6
If I do a Int ( (5 * 1.2)) , I receive the value 5, but I should receive 6?
Is this a bug or something really "normal".
I can see that if I...
|
by: LineVoltageHalogen |
last post by:
Greetings All, I was hoping that someone out there has run into this
issue before and can shed some light on it for me. I have a stored
procedure that essentially does a mini ETL from a source...
|
by: Arnold Schrijver |
last post by:
I wrote a program that draws items to the screen and maintains a set of
Offset values.
There was a bug in the code, because objects were positioned wrongly. While
debugging
I found some peculiar...
|
by: Boni |
last post by:
Dear all,
class A
overridable sub s1(byval a as integer)
end sub
overridable sub s2(byval a as integer, byval b as integer)
end sub
end class
class B
inherits class A
|
by: M.Posseth |
last post by:
Hello ,
I have a strange problem
when i set a reference to
http://www.trostonline.de/autobest/tolwebservice.dll/wsdl/ITOLServiceInterface
i end up with a logon method like this
|
by: annecarterfredi |
last post by:
I was getting snapshot since the database was responding very
slow...here is the query that was in a snapshot:
WITH TYPEINTS ( TYPEINT, COLTYPE ) AS ( VALUES ( SMALLINT(1 ),
CHAR( 'INTEGER', ...
|
by: Victor Lin |
last post by:
Now I am now developing a program that base on sqlite3 in python.
But there is a strange problem.
That is, all data I insert into sqlite database do not goes into file
in disk.
It is really...
|
by: djpaul |
last post by:
Hello,
I have this program and when i want to load pictures it crashes at the form.showdialog()....???
Here it goes:
Private Sub CmbPath_SelectedIndexChanged(ByVal sender As Object, ByVal e As...
|
by: raylopez99 |
last post by:
The below did not set off my compiler, perhaps because I set the
warnings to a higher (less nag) level.
Strange.
FYI, no question being asked.
RL
double d2030;
|
by: emmanuelkatto |
last post by:
Hi All, I am Emmanuel katto from Uganda. I want to ask what challenges you've faced while migrating a website to cloud.
Please let me know.
Thanks!
Emmanuel
|
by: nemocccc |
last post by:
hello, everyone, I want to develop a software for my android phone for daily needs, any suggestions?
|
by: Sonnysonu |
last post by:
This is the data of csv file
1 2 3
1 2 3
1 2 3
1 2 3
2 3
2 3
3
the lengths should be different i have to store the data by column-wise with in the specific length.
suppose the i have to...
|
by: marktang |
last post by:
ONU (Optical Network Unit) is one of the key components for providing high-speed Internet services. Its primary function is to act as an endpoint device located at the user's premises. However,...
|
by: Hystou |
last post by:
Most computers default to English, but sometimes we require a different language, especially when relocating. Forgot to request a specific language before your computer shipped? No problem! You can...
|
by: jinu1996 |
last post by:
In today's digital age, having a compelling online presence is paramount for businesses aiming to thrive in a competitive landscape. At the heart of this digital strategy lies an intricately woven...
|
by: Hystou |
last post by:
Overview:
Windows 11 and 10 have less user interface control over operating system update behaviour than previous versions of Windows. In Windows 11 and 10, there is no way to turn off the Windows...
|
by: agi2029 |
last post by:
Let's talk about the concept of autonomous AI software engineers and no-code agents. These AIs are designed to manage the entire lifecycle of a software development project—planning, coding, testing,...
|
by: isladogs |
last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM).
In this session, we are pleased to welcome a new...
| |
