Why use Macros in C? [duplicate]

Answer 1

One reason is until C99, the inline keyword was not standard in the C language. Thus macros allowed you to inline small functions. They also in some ways work like templates, ie. you don't have to specify types in the macro definition eg:

#define MAX(x,y) ((x) > (y) ? (x) : (y))

This macro is complient with integers, doubles, floats etc.

Answer 2

Macros are expanded at compilation time. You are correct that they are often abused but a classic example in C would be to have a macro for writing debugging messages which (when debug mode is turned off at compilation time) doesn't generate any code so causes no slowdown.

Answer 3

I think that biggest advantage comes when used as "setting file"

#define USE_FAST_AGORHITM
//#define USE_SLOW_ONE

And global "constants"

#define MAX_NUMBER_OF_USERS 100000

There are programs written mostly in macros (Check for instance Brian Gladman's AES implementation http://www.gladman.me.uk/cryptography_technology/index.php )

Answer 4

It's not exactly search and replace, it's token expansion. C macros are what every other kind of macro is in the computing world: a way to write something short and simple and have it automatically turn into something longer and more complicated.

One reason macros are used is performance. They are a way of eliminating function call overhead because they are always expanded in-line, unlike the "inline" keyword which is an often-ignored hint to the compiler, and didn't even exist (in the standard) prior to C99. For example, see the FD_ family of macros used in conjunction with the fd_sets used by select and pselect. These fd_sets are really just bitsets, and the FD_ macros are hiding bit twiddling operations. It would be annoying to write out the bit twiddling yourself every time, and a function call would be a lot of overhead for such a fast operation if it were not inlined.

Also, macros can do some things that functions cannot. Consider token pasting. Since the preprocessor runs before the compiler, it can make new identifiers for the compiler to use. This can give you a shorthand way to create lots of similar definitions, e.g.

#define DEF_PAIR_OF(dtype) \
  typedef struct pair_of_##dtype { \
       dtype first; \
       dtype second; \
  } pair_of_##dtype##_t 

 DEF_PAIR_OF(int);
 DEF_PAIR_OF(double);
 DEF_PAIR_OF(MyStruct);
 /* etc */

Another thing it can do that a function could not is turn compile-time information into runtime information:

#ifdef DEBUG
#define REPORT_PTR_VALUE(v) printf("Pointer %s points to %p\n", #v, v)
#else 
#define REPORT_PTR_VALUE(v)
#endif

void someFunction(const int* reallyCoolPointer) {
  REPORT_PTR_VALUE(reallyCoolPointer);
  /* Other code */
}

There's no way that a function could use the name of its parameter in its output like the macro can. This also demonstrates compiling out debug code for release builds.

Answer 5

On Macros, the function's code gets inserted into the caller's code stream. This can, depending on many other things, improve performance, because the optimizer can procedurally integrate the called code — optimize the called code into the caller But beware, because on macros argument types are not checked. A good reference to inline functions (if you are also using C++) and a little bit of macros is. http://www.parashift.com/c++-faq-lite/inline-functions.html#faq-9.5

Answer 6

C macros can generate code at compile time. This can be (ab)used to effectively create domain-specific languages with new keywords and behaviors.

One of my favorite examples is Simon Tatham’s method of implementing coroutines in C through macros. The simplest macro implemented is:

#define crBegin static int state=0; switch(state) { case 0:

Yes, with an unmatched brace. Other macros will fix that up.