Why do I get a warning when using an int variable but not when using an integer constant?

Question

I have two versions of a piece of code. The first is by using an int variable as part of an expression for a condition test, the second by using an integer constant for the same - both represent the same integral value - 24 .

1. code :

#include <stdio.h>

int main()
{
    int var = 24;

    if((!var) == NULL)
    {
        printf("1");
    }
}

2. code :

#include <stdio.h>

int main()
{
    if((!24) == NULL)
    {
        printf("1");
    }
}

---

When I attempt to compile the first version, I get the warning:

warning: comparison between pointer and integer

from gcc, and

warning: comparison between pointer and integer ('int' and 'void *') [-Wpointer-integer-compare]

from clang.

When I compile the almost equivalent code by using the same value just as integer constant, everything is fine. Why?

---

My research so far:

I looked into C18 and found on section 6.4.4 "Constants":

First under Subsection /2 and /3:

" 2 - Each constant shall have a type and the value of a constant shall be in the range of representable values for its type. "

" 3 - Each constant has a type, determined by its form and value, as detailed later. ".

And second under Subsection /5:

" The type of an integer constant is the first of the corresponding list in which its value can be represented. "

The following list:

Thus, an integer constant with no suffix and relative to the representable value of 24 should have type int .

---

I understand the warning itself and know that NULL usually on most implementations expands to (void*) 0 . Thus, it is reasonable that this warning is thrown.

But why does the warning not occur when using the same value as integer constant?

Answer 1

From C11 6.3.2.3/3:

An integer constant expression with the value 0, or such an expression cast to type void *, is called a null pointer constant.

And from 6.5.9/2 regarding equality operators == and != :

One of the following shall hold:
...
— one operand is a pointer and the other is a null pointer constant.

Note that integer constant expressions are not limited to integer constants (0, 42, etc.) but can also include operators acting on them like 5+5-10 .

!24 is an integer constant expression with the value 0, and therefore counts as a null pointer constant. The == operator is allowed to act between a pointer and a null pointer constant, which makes (!24) == NULL a valid comparison.

In your first example, !var is not an integer constant expression because it includes a variable operand, and thus cannot be compared with a pointer.

Caveat: In most implementations, NULL is defined as (void*)0 and the above is correct. However, the standard allows it to be defined it as any null pointer constant such as 0 . If this is the case, then the comparison (!var) == NULL will compile because it is the same as (!var) == 0 .