Is there a good reason for always enclosing a define in parentheses in C?

by

Yes. The preprocessor concatenation operator (##) will cause issues, for example:

#define _add_penguin(a) penguin ## a
#define add_penguin(a) _add_penguin(a)

#define WIDTH (100)
#define HEIGHT 200    

add_penguin(HEIGHT) // expands to penguin200
add_penguin(WIDTH)  // error, cannot concatenate penguin and (100)

Same for stringization (#). Clearly this is a corner case and probably doesn’t matter considering how WIDTH will presumably be used. Still, it is something to keep in mind about the preprocessor.

(The reason why adding the second penguin fails is a subtle detail of the preprocessing rules in C99 – iirc it fails because concatenating to two non-placeholder preprocessing tokens must always result in a single preprocessing token – but this is irrelevant, even if the concatenation was allowed it would still give a different result than the unbracketed #define!).

All other responses are correct only insofar that it doesn’t matter from the point of view of the C++ scanner because, indeed, a number is atomic. However, to my reading of the question there is no sign that only cases with no further preprocessor expansion should be considered, so the other responses are, even though I totally agree with the advice contained therein, wrong.

More Related Contents:

  1. The need for parentheses in macros in C [duplicate]
  2. C macros and use of arguments in parentheses
  3. How can I concatenate twice with the C preprocessor and expand a macro as in “arg ## _ ## MACRO”?
  4. Overloading Macro on Number of Arguments
  5. Should I use #include in headers?
  6. How to make a variadic macro (variable number of arguments)
  7. Is it possible to iterate over arguments in variadic macros?
  8. “#include” a text file in a C program as a char[]
  9. How to write a while loop with the C preprocessor?
  10. Including one C source file in another?
  11. How, exactly, does the double-stringize trick work?
  12. What exactly do C include guards do?
  13. Array-size macro that rejects pointers
  14. Convert a preprocessor token to a string
  15. Can gcc output C code after preprocessing?
  16. Why does the C preprocessor interpret the word “linux” as the constant “1”?
  17. Shall I prefer constants over defines?
  18. Macro returning the number of arguments it is given in C? [duplicate]
  19. What do the parentheses around a function name mean?
  20. Seeing expanded C macros
  21. Indenting #defines
  22. What are C macros useful for?
  23. Opposite of C preprocessor “stringification”
  24. Why do most C developers use define instead of const? [duplicate]
  25. C Macros to create strings
  26. Why does #define not require a semicolon?
  27. Is the sizeof(enum) == sizeof(int), always?
  28. Are constant C expressions evaluated at compile time or at runtime?
  29. Changing a macro at runtime in C
  30. How do I print a #defined constant in GDB?

Leave a Comment