Macro vs Function in C

by

Macros are error-prone because they rely on textual substitution and do not perform type-checking. For example, this macro:

#define square(a) a * a

works fine when used with an integer:

square(5) --> 5 * 5 --> 25

but does very strange things when used with expressions:

square(1 + 2) --> 1 + 2 * 1 + 2 --> 1 + 2 + 2 --> 5
square(x++) --> x++ * x++ --> increments x twice

Putting parentheses around arguments helps but doesn’t completely eliminate these problems.

When macros contain multiple statements, you can get in trouble with control-flow constructs:

#define swap(x, y) t = x; x = y; y = t;

if (x < y) swap(x, y); -->
if (x < y) t = x; x = y; y = t; --> if (x < y) { t = x; } x = y; y = t;

The usual strategy for fixing this is to put the statements inside a “do { … } while (0)” loop.

If you have two structures that happen to contain a field with the same name but different semantics, the same macro might work on both, with strange results:

struct shirt 
{
    int numButtons;
};

struct webpage 
{
    int numButtons;
};

#define num_button_holes(shirt)  ((shirt).numButtons * 4)

struct webpage page;
page.numButtons = 2;
num_button_holes(page) -> 8

Finally, macros can be difficult to debug, producing weird syntax errors or runtime errors that you have to expand to understand (e.g. with gcc -E), because debuggers cannot step through macros, as in this example:

#define print(x, y)  printf(x y)  /* accidentally forgot comma */
print("foo %s", "bar") /* prints "foo %sbar" */

Inline functions and constants help to avoid many of these problems with macros, but aren’t always applicable. Where macros are deliberately used to specify polymorphic behavior, unintentional polymorphism may be difficult to avoid. C++ has a number of features such as templates to help create complex polymorphic constructs in a typesafe way without the use of macros; see Stroustrup’s The C++ Programming Language for details.

More Related Contents:

  1. what is the return type of printf [closed]
  2. Changing address contained by pointer using function
  3. Why isn’t the size of an array parameter the same as within main?
  4. C sizeof a passed array [duplicate]
  5. Overloading Macro on Number of Arguments
  6. Should I use #include in headers?
  7. How to make a variadic macro (variable number of arguments)
  8. Must declare function prototype in C? [duplicate]
  9. “#include” a text file in a C program as a char[]
  10. How to write a while loop with the C preprocessor?
  11. Implicit int return value of C function
  12. How, exactly, does the double-stringize trick work?
  13. Tools to get a pictorial function call graph of code [closed]
  14. C – function inside struct
  15. C error: undefined reference to function, but it IS defined
  16. Shall I prefer constants over defines?
  17. Macro returning the number of arguments it is given in C? [duplicate]
  18. What do the parentheses around a function name mean?
  19. Call a function named in a string variable in C
  20. Seeing expanded C macros
  21. Indenting #defines
  22. Why use an asterisk “[*]” instead of an integer for a VLA array parameter of a function?
  23. What are C macros useful for?
  24. Opposite of C preprocessor “stringification”
  25. Why does #define not require a semicolon?
  26. How can I return a character array from a function in C?
  27. Unspecified number of parameters in C functions – void foo()
  28. Are constant C expressions evaluated at compile time or at runtime?
  29. Changing a macro at runtime in C
  30. How sqrt() of GCC works after compiled? Which method of root is used? Newton-Raphson?

Leave a Comment