Many sources online (for example, https://en.cppreference.com/w/cpp/preprocessor/conditional#Condition_evaluation) say that the expression need only be an integer constant expression.

The following are all integral constant expressions without any identifiers in them:

#include <compare>

#if (1 <=> 2) > 0
#error 1 > 2
#endif

#if (([]{}()), 0)
#error 0
#endif

#if 1.2 < 0.0
#error 1.2 < 0.0
#endif

#if ""[0]
#error null terminator is true
#endif

#if *""
#error null terminator is true
#endif

Yet they fail to compile with clang or gcc, so there obviously are some limitations.

The grammar for the #if directive is given in [cpp.pre] in the standard as:

if-group:
# if constant-expression new-line group_opt

All of the previous expressions fit the grammar of constant-expression.

It goes on later to say (in [cpp.cond]):

1/
The expression that controls conditional inclusion shall be an integral constant expression except that identifiers (including those lexically identical to keywords) are interpreted as described below

8/
Each preprocessing token that remains (in the list of preprocessing tokens that will become the controlling expression) after all macro replacements have occurred shall be in the lexical form of a token.

All of the preprocessing tokens seem to be in the form of [lex.token]:

token:
identifier
keyword
literal
operator-or-punctuator

<=>, >, [, ], {, }, (, ), * are all an operator-or-punctuator

1, 2, 0, 1.2, 0.0, "" are all literals

So what part of the standard rules out these forms of expressions? And what subset of integral constant expressions are allowed?

>Solution :

I think that all of these examples are intended to be ill-formed, although as you demonstrate the current standard wording doesn’t have that effect.

This seems to be tracked as active CWG issue 1436. The proposed resolution would disqualify string literals, lambdas, floating point literals and also <=> from #if conditions. (Although <=> was added to the language after the issue description was written.)