When and why use a #define macro(x) instead of function?

Question

Seeing this question made me wonder why the approach (toy example):

#define foo(x) bar[x] = 0

would ever be preferred over the function:

void foo(unsigned x){ bar[x] = 0; }

Before the question linked above, I've only seen this once before, in the PolarSSL library, where I assumed it to be some sort of optimisation, and tried not to think too much about it.

I assume that using the preprocessor macro replaces the 'call' to be the '(not-) function body' everywhere it exists; whereas the void function may or may not be optimised out by the compiler, and therefore may result in a lot of branching for a small and simple operation or two.

Is there any other benefit?

When is the macro method preferred, and when is it better to trust the compiler?

Tagged both C and C++ in anticipation that a partly style question might be different for each. — OJFord, Dec 21 '14 at 19:04
It is not preferred. Those kind of macros were ab/used when compilers did not have good optimizers yet. — Hans Passant, Dec 21 '14 at 19:06
Or before the [`inline` specifier](http://en.cppreference.com/w/c/language/inline) in C++ and C99. — Greg Hewgill, Dec 21 '14 at 19:07
@HansPassant Ah okay - I'll continue to steer clear myself then :) — OJFord, Dec 21 '14 at 19:08
If C++ is your language then almost always the inline function is a better option, as [macros are evil](http://www.parashift.com/c++-faq-lite/macros-with-if.html). — legends2k, Dec 21 '14 at 19:12
C++ equivalent question: http://stackoverflow.com/questions/96196/when-are-c-macros-beneficial — abligh, Dec 21 '14 at 19:16
C equivalent question: http://stackoverflow.com/questions/9104568/macro-vs-function-in-c — abligh, Dec 21 '14 at 19:16
Not everything that can be done with macros can be done with a function. Learn what macros can do, but use a function when a function can accomplish the same thing. They don't need to be avoided entirely. — Dmitri, Dec 21 '14 at 20:25

score 9 · Accepted Answer · edited May 23 '17 at 12:06

9

Firstly, I'd hope your macro was actually:

#define foo(x) do { bar[x] = 0; } while (0)

for proper semicolon swallowing.

One thing in favour of macros is because you think your compiler's optimiser is not good enough. You're probably wrong. But if you've actually looked at the output carefully and know what you are doing, you might be right, which is why it's often used in the Linux kernel.

Another reason is that macros are typeless, so you might do:

#define foo(x,t) do { t[x] = 0; } while (0)

which will work for any type t. Lack of type checking is often a disadvantage, but it can be useful when defining something you want to work with any type.

edited May 23 '17 at 12:06

Community

1
1

answered Dec 21 '14 at 19:14

abligh

24,573
4
47
84

4

The “other” reason has become obsolete in C++ due to templates. – 5gon12eder Dec 21 '14 at 19:16
I've never used one, I just made it up, so I was choking on semicolons unfortunately. – OJFord Dec 21 '14 at 19:17
1

Sure, but this is tagged `C` and `C++` – abligh Dec 21 '14 at 19:17
@5gon12eder I asked about for C as well - because I'm interested at differences/both sides like this. – OJFord Dec 21 '14 at 19:17
1

Yes but this is also a problem which is why I've left the comment. A reasonable use of macros in C might be a terrible one in C++. Maybe I should have phrased it as: “In C++, the other use has become obsolete due to templates.” – 5gon12eder Dec 21 '14 at 19:20
@5gon12eder Apologies, I mistook it for a correction. – OJFord Dec 21 '14 at 19:37

score 8 · Answer 2 · answered Dec 21 '14 at 19:17

Defining macro just to make the code faster is useless. A good compiler will inline function call. However, macros can be useful when you need to use their result as constant.

#define ENCODED(a,b,c,d) (((((((a)<<8)+b)<<8)+c)<<8)+d)

switch (a) {
   case ENCODED('f','o','o','0'):   ...
   case ENCODED('b', 'a', 'r', '1'): ...
}

When you want to define new identifiers:

#define LIB_VERSION v101
#define VERSIONNED(x) x##LIB_VERSION

void VERSIONNED(myfunction)(int x) { ... }

When you want to do some other "magics",. For example:

#define assert(x) {if ((x) == 0) {printf("%s:%d: Assertion %s failed\n", __FILE__, __LINE__, #x); exit(-1); }}

When you want to define a "generic" function working with several types. Just for illustration:

#define DELETE_LAST_ITEM(x) {while (x->next->next != NULL) x=x->next ; x->next = NULL}

and probably some other situations which I do not remember right now.

The constant result is a valid reason for using a function-like macro in C. In C++ this is not needed and considered a bad thing. A `constexpr` can be used anywhere a compile-time constant is required. And templates can help make it work with arbitrary types. — 5gon12eder, Dec 21 '14 at 19:23

score 4 · Answer 3 · answered Dec 21 '14 at 19:12

Is there any other benefit?

There are few situational benefits of using macro. Just for an example, you may use __LINE__ and __FILE__ to see where this macro is getting called for debugging.

#define foo(x) bar[x] = 0; PrintFunction("...", __FILE__,__LINE__)

The macro would never give you stronger type checking like function.

When is the macro method preferred, and when is it better to trust the compiler?

Hence, Macro should be preferred only when you don't have any choice left to use a function, because most of the times you may trust the compiler optimizer.

When and why use a #define macro(x) instead of function?

3 Answers3