Why should I avoid macros in C++? [closed]

by

Macros don’t respect scoping rules and operate at the textual level, as opposed to the syntax level. From this arise a number of pitfalls that can lead to strange, difficult to isolate bugs.

Consider the following well-known example:

#define max(a, b) ((a) < (b) ? (b) : (a))
⋮
int i = max(i++, j++);

The preferred alternative in this case is a function template:

template <typename T>
T max(const T & a, const T & b) { return a < b ? b : a; }

Here’s another case that leads to subtle problems:

#define CHECK_ERROR(ret, msg) \
    if (ret != STATUS_OK) { \
        fprintf(stderr, "Error %d: %s\n", ret, msg); \
        exit(1); \
    }
⋮
if (ready)
    CHECK_ERROR(try_send(packet), "Failed to send");
else
    enqueue(packet);

You might think that the solution is as simple as wrapping the contents of CHECK_ERROR in { … }, but this won’t compile due to the ; before the else.

To avoid the above problem (the else attaching to CHECK_ERROR‘s if instead of the outer if), one should wrap such macros in do … while (false) as follows (and also avoid the duplicate ret):

#define CHECK_ERROR(op, msg) \
  do { \
    int ret = (op); \
    if (ret != STATUS_OK) { \
        fprintf(stderr, "Error %d: %s\n", ret, msg); \
        exit(1); \
    } \
  while (false)

This has no effect on the meaning of the macro, but ensures that the entire block is always treated as a single statement and doesn’t interact in surprising ways with if statements.

Long story short, macros are hazardous at many levels and should thus be used only as a last resort.

More Related Contents:

  1. Which of the following implementations is faster? [closed]
  2. Inline functions vs Preprocessor macros
  3. Comma in C/C++ macro
  4. Can we have recursive macros?
  5. What is the worst real-world macros/pre-processor abuse you’ve ever come across?
  6. Optional Parameters with C++ Macros
  7. Is there a __CLASS__ macro in C++?
  8. What does the Q_OBJECT macro do? Why do all Qt objects need this macro?
  9. C++ – enum vs. const vs. #define
  10. Instantiate class from name?
  11. How to identify platform/compiler from preprocessor macros?
  12. What does “#pragma comment” mean?
  13. Is #pragma once part of the C++11 standard?
  14. Are C++ Templates just Macros in disguise?
  15. Is there a way to get function name inside a C++ function?
  16. Why do I need double layer of indirection for macros?
  17. Reason why not to have a DELETE macro for C++
  18. What is the difference between a macro and a const in C++?
  19. macro definition containing #include directive
  20. How to generate random variable names in C++ using macros?
  21. C++ type registration at compile time trick
  22. Self-unrolling macro loop in C/C++
  23. Can I redefine a C++ macro then define it back?
  24. Confused by squaring macro SQR in c [duplicate]
  25. How to find out cl.exe’s built-in macros
  26. Generate include file name in a macro
  27. Problem with Macros
  28. Expand macro inside string literal
  29. How can I define a string literal on the GCC command line?
  30. How can you compare two character strings statically at compile time

Leave a Comment