Defect Report #172
Submission Date: 16 Oct 95
Source: Clive D.W. Feather
Submitted to BSI by Clive D.W. Feather email@example.com .
In this Defect Report, identifiers lexically identical to those
declared in standard headers refer to the identifiers declared in those
standard headers, whether or not the header is explicitly mentioned.
This Defect Report has been prepared with considerable help from
Mark Brader, Jutta Degener, Ronald Guilmette, and a person whose
employment conditions require anonymity. However, except where stated,
opinions expressed or implied should not be assumed to be those of any
person other than myself.
Defect Report UK 020: Relational and equality operators
The descriptions of these operators with pointer operands contain
Consider the following code:
char *s = "a string";
if (s = NULL)
/* ... */
Subclause 6.3.8, Semantics reads in part:
If the objects pointed to are not members of the same aggregate
or union object, the result is undefined
This implies that the comparison causes undefined behavior.
Subclause 22.214.171.124 reads in part:
Such a pointer, called a null pointer, is guaranteed to compare
unequal to a pointer to any object or function.
This implies that the comparison is guaranteed to yield false.
This is a direct contradiction.
Subclause 6.3.9, Semantics reads in part:
Where the operands have types and values suitable for the
relational operators, the semantics detailed in subclause 6.3.8 apply.
This can reasonably be read as meaning that, whenever the
constraints of subclause 6.3.8 apply, its definitions should be used,
even if that would result in undefined behavior. (The phrase and
values can reasonably be read as requiring only that the pointers
both be to objects; it does not necessarily mean that the result of the
comparison must be defined.)
It further reads:
If two pointers to object or incomplete types are both null
pointers, they compare equal. If two pointers to object or incomplete
types compare equal, they both are null pointers, or both point to the
same object, or both point one past the last element of the same array
This says nothing about the comparison of any other pointers. Now,
subclause 3.16 reads in part:
Undefined behavior is otherwise indicated ... by the omission of
any explicit definition of behavior.
int a, b;
&a == &b
the comparison causes undefined behavior!
The above citation does not allow for the case where one pointer
is to an object, and the other is one past the last element of an array
object. If an implementation places two independent objects in adjacent
memory locations, a pointer to one would equal a pointer to just past
the other on many common implementations.
If these pointers are not to be viewed as identical, then the
wording is defective.
Suggested Technical Corrigendum
In subclause 126.96.36.199, replace the cited text by:
Such a pointer is called a null pointer.
In subclause 6.3.9, replace the first paragraph of the semantics
The operators == (equal to) and !=
(not equal to) shall yield 1 if the specified relation is true and 0 if
it is false. If the operands have types suitable for those of a
relational operator and values that would not cause undefined behavior
if used with a relational operator, then the result of the comparison,
either greater than or less than (both implying not equal to) or equal
to, is the same as with a relational operator.
Insert at the start of the second paragraph:
Otherwise the operands are pointers, and they shall compare
either equal or not equal.
If part 3 is viewed as an issue, then in the same paragraph
or both point one past the last element of the same array object.
both point one past the last element of the same array object, or
one points one past the last element of some array object and the other
points to the first element of a different array object.
This is a work in progress item.
Summary of Part 1:
The standard does not currently state what happens with relational
operators when you compare the address of an object with a null
We know from the citation from subclause 188.8.131.52 that a null
pointer is guaranteed to yield false when compared with a pointer to an
It is explicitly undefined behaviour to use relational operators
on two pointer that are not members of the same aggregate or union
object. However it is unstated whether a null pointer compares greater
or less than the address of an object and hence is implicitly undefined
Is this the desired behaviour?
Note: the current C++ clause has the following wording:
If two pointers of the same type point to different objects or
functions, or only one of them is null, they compare unequal.
This wording gives the possibility for C and C++ to give different
Summary of Part 2:
Discussion from Nashua is as follows:
The intent is that pointers to distinct object will compare
unequal, The C Standard will be fixed in a future revision.
Previous Defect Report
< - >
Next Defect Report