Macro comparison in C has incorrect result

Why output of the following code is 10 instead of the expected 20?

#define A double

#if A == float
    #define X 10
#elif A == double
    #define X 20
#endif

int main() {
    return X;
}

Try it: https://godbolt.org/z/r8xhq5Pja

The standard says that in a preprocessor conditional, any identifier that is left over after macro expansion is done is treated as zero. Both float and double become 0 — the result of the conditions is therefore #define X 10 and the program returns 10 to the environment.

See (C11) §6.10.1 Conditional Inclusion, especially ¶4 (emphasis added):

> ¶4 4 Prior to evaluation, macro invocations in the list of preprocessing tokens that will become the controlling constant expression are replaced (except for those macro names modified by the defined unary operator), just as in normal text. If the token defined is generated as a result of this replacement process or use of the defined unary operator does not match one of the two specified forms prior to macro replacement, the behavior is undefined. After all replacements due to macro expansion and the defined unary operator have been performed, all remaining identifiers (including those lexically identical to keywords) are replaced with the pp-number 0, and then each preprocessing token is converted into a token. The resulting tokens compose the controlling constant expression which is evaluated according to the rules of 6.6. For the purposes of this token conversion and evaluation, all signed integer types and all unsigned integer types act as if they have the same representation as, respectively, the types intmax_t and uintmax_t defined in the header <stdint.h>.¹⁶⁷⁾ This includes interpreting character constants, which may involve converting escape sequences into execution character set members. Whether the numeric value for these character constants matches the value obtained when an identical character constant occurs in an expression (other than within a #if or #elif directive) is implementation-defined.¹⁶⁸⁾ Also, whether a single-character character constant may have a negative value is implementation-defined.

That's not how the C preprocessor works.

First your code boils down to this, because of #define A double:

#if double == float
    #define X 10
#elif double == double
    #define X 20
#endif
...

Neither of the preprocessor symbols double or float has been #defined. Therefore both preprocessor symbols double and float are implicitly 0 and therefore #if double == float is equivalent to #if 0 == 0 which is, of course, true.

At the preprocessor level, double and float are not C keywords but just preprocessor tokens.

As other answers have described, the C preprocessor does not provide for comparing (preprocessor) token text. In a conditional directive, the condition is first expanded. Then, any remaining preprocessing tokens of type "identifier" are replaced by 0. If this results in a sequence of tokens that can be interpreted as an expression, then it is necessarily a constant expression. Otherwise, the behavior is undefined.

You said in comments that your objective is to simulate C++ templates. I would be inclined to suggest writing in bona fide C++ if you want templates. Nevertheless, there are ways to approach the problem in C, depending on just what aspects of templates you want to simulate. The two preprocessor features most applicable to the task would probably be token pasting and function-like macros.

Taking the token-pasting first, here's a way to achieve the behavior you seem to have wanted your example code to manifest:

#define A double

#define floatval 10
#define doubleval 20

#define JOIN_HELPER(x, y) x ## y
#define JOIN(x, y) JOIN_HELPER(x, y) 
#define X JOIN(A, val)

int main() {
    return X;
}

Depending on the definition of A as either float or double, that JOIN(A, val) invocation expands to either floatval or doubleval, which in turn expands to either 10 or 20. You can use similar to generate C identifiers, not just macro names. For example, you could generate function names that incorporate the expansion of macro A.

But function-like macros seem a likely headliner here. Consider this:

#define SUM_FUNC(type)                 \
type JOIN(sum, type)(type x, type y) { \
    return x + y;                      \
}

For any arithmetic type, type, that macro will expand to a function sumtype, accepting two arguments of type type and returning their sum as a type.