Can a null pointer constant be any integer constant expression evaluated to 0?

Question

The standard says:

"An integer constant expression with the value 0, or such an expression cast to type void*, is called a null pointer constant.67) 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."

"67) The macro NULL is defined in stddef.h (and other headers) as a null pointer constant; see 7.19."

Source: ISO/IEC 9899:2018 (C18), §6.2.3.2/3 "Pointers".

The most common null pointer constants are of course, 0 and (void*) 0 used by most implementations as null pointer constant, but as the standard mandates - "An integer constant expression with the value 0, or such an expression cast to type void*" - a null pointer constant shall also be any of the following:

1 * 0
0 * 0
0 - 0
25 - 25
(-4) + (4)
(0 * ((0 * 25) * 3)
(0) * (-100)

Like any of their pendants preceded by (void*), f.e. (void*) (1 * 0) or (void*) (25 - 25).

As well as boolean expressions:

(void*) ((1 + 1) == 25)
(void*) !(9)

Thus, any statement like one of these:

int* ptr = 25 - 25;
int* ptr = (void*) ((-4) + 4);
int* ptr = (0 * ((0 * 25) * 3);
int* ptr = (void*) !(9);
int* ptr = ((1 + 1) == 25);

shall make ptr, per standard, a null pointer.

Am I correct or is there anything wrong about my concerns?

I am looking for any part of the C standard which invalidates this thesis.

As far as I searched, there shouldn´t be a duplicate of this question on Stack Overflow.

I am not sure the standard guarantee that 25 - 25 is a constant. — Eugene Sh.
– Eugene Sh., Commented May 11, 2020 at 16:48
I don't see why these wouldn't work. Note that your question title ("Can ... any expression evaluated to 0") is different and is not true. For example, (void*) strlen("") would not be guaranteed to be a null pointer. — jamesdlin
– jamesdlin, Commented May 11, 2020 at 16:52
port70.net/~nsz/c/c11/n1570.html#6.6 - It looks like the necessary conditions are listed, but not the sufficient ones. So I am not sure an expression can be guaranteed to be constant. — Eugene Sh.
– Eugene Sh., Commented May 11, 2020 at 16:53

dbush · Accepted Answer · 2020-05-11 16:58:32Z

You are correct that all of these are valid.

Section 6.6 of the C standard states:

1
constant-expression:
    conditional-expression
...

3 Constant expressions shall not contain assignment, increment, decrement, function-call,or comma operators, except when they are contained within a subexpression that is not evaluated.

...

6 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, _Alignof expressions, and floating constants that are the immediate operands of casts. Cast operators in an integer constant expression shall only convert arithmetic types to integer types, except as part of an operand to the sizeof or _Alignof operator.

Each of the expressions in your examples fit this description, i.e.:

All operands are integer constants
The expression is a conditional-expression (i.e. doesn't use assignment or comma operators) with no increment, decrement, or function call operators
Evaluates to 0

So all are valid ways to assign NULL to a pointer.

Some examples that are not integer constant expressions:

int x = 1;
int *ptr1 = (3, 0);    //  invalid, comma operator not allowed
int *ptr2 = (x = 0);   //  invalid, assignment not allowed
int *ptr3 = x - 1;     //  invalid, an operand is not an integer constant

Asteroids With Wings · Accepted Answer · 2020-05-11 16:49:43Z

2

Yep.

[C99 6.6/6]: 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. Cast operators in an integer constant expression shall only convert arithmetic types to integer types, except as part of an operand to the sizeof operator.

Note that this is not the case in C++, where null pointer constants are defined differently:

[conv.ptr]/1: A null pointer constant is an integer literal ([lex.icon]) with value zero or a prvalue of type std::nullptr_t. [..]

answered May 11, 2020 at 16:49

Asteroids With Wings

17.7k2 gold badges25 silver badges36 bronze badges

2 Comments

Eugene Sh. Over a year ago

The conclusion should be stated

Asteroids With Wings Over a year ago

@EugeneSh. The conclusion is in the first line.

Collectives™ on Stack Overflow

Can a null pointer constant be any integer constant expression evaluated to 0?

2 Answers 2

Comments

2 Comments

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

Comments

2 Comments

Your Answer

Sign up or log in

Post as a guest

Linked

Related