Why no warning with "#if X" when X undefined?

Question

I occasionally write code something like this:

// file1.cpp
#define DO_THIS 1

#if DO_THIS
    // stuff
#endif

During the code development I may switch the definition of DO_THIS between 0 and 1. Recently I had to rearrange my source code and copy some code from one file to another. But I found that I had made a mistake and the two parts had become separated like so:

// file1.cpp
#define DO_THIS 1

and

// file2.cpp
#if DO_THIS
    // stuff
#endif

Obviously I fixed the error, but then thought to myself, why didn't the compiler warn me? I have the warning level set to 4. Why isn't #if X suspicious when X is not defined?

One more question: is there any systematic way I could find out if I've made the same mistake elsewhere? The project is huge.

EDIT: I can understand having no warning with #ifdef that makes perfect sense. But surely #if is different.

Answer 1

The compiler didn't generate a warning because this is a preprocessor directive. It's evaluated and resolved before the compiler sees it.

Answer 2

gcc can generate a warning for this, but its probably not required by the standard:

-Wundef
Warn if an undefined identifier is evaluated in an `#if' directive.

Answer 3

Again, as it often happens, the answer to the "why" question is just: it was done that way because some time ago it was decided to do it this way. When you use an undefined macro in an #if it is substituted with 0. You want to know whether it is actually defined - use defined() directive.

There some interesting benefits to that "default to 0" approach though. Especially when you are using macros that might be defined by the platform, not our own macros.

For example, some platforms offer macros __BYTE_ORDER, __LITTLE_ENDIAN and __BIG_ENDIAN to determine their endianness. You could write preprocessor directive like

#if __BYTE_ORDER == __LITTLE_ENDIAN
  /* whatever */
#else
  /* whatever */
#endif

But if you try to compile this code on a platform that does not define these non-standard macros at all (i.e. knows nothing about them), the above code will be translated by preprocessor into

#if 0 == 0
...

and the little-endian version of the code will be compiled "by default". If you wrote the original #if as

#if __BYTE_ORDER == __BIG_ENDIAN
...

then the big-endian version of the code would be compiled "by default".

I can't say that #if was defined as it was specifically for tricks like the above, but it comes useful at times.

Answer 4

If I'm thinking about this correctly.

Preprocessor directives are handled before any source code is compiled. During that phase(s) of translation in which this occurs all preprocessor directives, macros, etc are handled and then the actual source code is compiled.

Since #if is used to determine if X has been defined and carry out some action if it has or has not been defined. The #if in the code snippet would compile without any errors because there aren't any errors as far as the compiler is concerned. You could always create a header file with specific #defines that your application would need and then include that header.