Function like Macros in C

Question

I am trying to understand the idea of function like Macros however there are a few points that befuddle me. For example say we have:

#define Max(a,b)  ((a)>(b)) ? (a):(b))

and I call it like such

int i = Max(4,5);

This will evaluate a conditional expression equivalent to a>b? If yes then a, else b. But I'm confused as to how the Max function knows what to do with the arguments. Unlike an actual function, the implementation isn't written in code in the calling program. is the statement to the right of the define statement doing this for me? Its just a new thing for me and I want to make sure I understand what is happening here.

This particular part of function like macros confuses me. I know that these types of macros are useful for reducing overhead costs since they exclude the JSR RTS processor instructions which saves memory on the stack.

This is not a function. A macro is literally just text substitution, that occurs before the compiler runs. — Oliver Charlesworth, Mar 22 '13 at 16:37
[This](http://gcc.gnu.org/onlinedocs/cpp/Macro-Arguments.html) may help. — ajp15243, Mar 22 '13 at 16:38
Do you realize that the '?' is a ternary conditional operator? — Randy Howard, Mar 22 '13 at 16:39
I am unfamiliar with ternary conditional operators, but my confusion was more with how the macro implements into the entire program. @OliCharlesworth I am aware that it is not an actual function but behaves function-like. — PresidentRFresh, Mar 22 '13 at 16:43
@PresidentRFresh: Ok, then I'm not sure exactly what your question is asking about! — Oliver Charlesworth, Mar 22 '13 at 16:43
Thats okay I am bad at wording questions. I was basically asking how a macro like the above operates. Im use to seeing #define "some number" but it have never seen #define with macros. — PresidentRFresh, Mar 22 '13 at 16:45

score 13 · Accepted Answer · edited Mar 22 '13 at 16:48

13

#define Max(a,b)  ((a)>(b)) ? (a):(b))

is a macro, that causes nothing else but a simple textual replacement within your code, which means that during the preprocessing this line:

int i = Max(4,5);

is changed into:

int i = ((4)>(5)) ? (4):(5));

Note that there is no type safety while working with macros like this one and you will have really hard time while debugging your code as well. Good rule of thumb is: Don't use macro when you can achieve the same with function:

int max(int a, int b) {
    return (a > b) ? a : b;
}

edited Mar 22 '13 at 16:48

Guilherme Bernal

8,183
25
43

answered Mar 22 '13 at 16:45

LihO

41,190
11
99
167

Ah so by type safety you mean that I could theoretically pass an int, char, etc and it would still be valid? – PresidentRFresh Mar 22 '13 at 16:47
7

I actually think this particular example involving `max()` is a great time to use a macro instead of a function. In C, where there are no templates or generics, you'd have to write a separate `max()` function for each type, whereas with a simple macro it all Just Works (for types where `>` is meaningful). – Graham Borland Mar 22 '13 at 16:50
1

@PresidentRFresh: Anything can be "passed" to this macro. The problem is that sometimes it might lead to buggy behavior (macros being used in a way they were not meant to be used). For example someone could pass pointers to it which would be compile-able but producing bad results. – LihO Mar 22 '13 at 16:51
@GrahamBorland: I agree that macros can be sometimes handy, but still there is a risk, that a programmer using them will make some mistake (could be just a silly typo) and this kind of error will be quite hard to find. – LihO Mar 22 '13 at 16:58
You could use the `inline` keyword to make it more like a macro, but with type safety. – kazmer Mar 02 '19 at 22:09

score 6 · Answer 2 · answered Mar 22 '13 at 16:56

Just stop thinking about macro like compilable code. Macros are "resolved" by pre-processor, not actually during compilation stage. So by macro definitions you just define how to process certain string in text file. Only output of pre-processor is passed to compiler. You can use gcc -E to see your source after pre-processor. It is still C code on this stage but without any preprocessor directive.

Hope this will help you.

Graham Borland · Answer 3 · 2013-03-22T16:44:41.787

5

What the compiler actually sees, after preprocessing, is:

int i = ((4)>(5)) ? (4):(5));

The parameters passed to the macro are substituted into the body of the macro.

edited Mar 22 '13 at 16:44

answered Mar 22 '13 at 16:38

Graham Borland

60,055
21
138
179

score 4 · Answer 4 · answered Mar 22 '13 at 16:38

4

try to build your code with the gcc -E and see how your code look before compiling it

In fact in the build process the compilator transform your actual code to a preprocessor code. In the preprocessor phase the compilator replace all macro in your c code with its content and generate another code called preprocessor code and then the compilateor generate the object code from the preprocessor code

The gcc -E allow you to see your preprocessor code

answered Mar 22 '13 at 16:38

MOHAMED

41,599
58
163
268

Oh I see. I am aware that this is not an actual function but I was confused as to how it operated. Thank you for clearing that up. – PresidentRFresh Mar 22 '13 at 16:44

Function like Macros in C

4 Answers4

Linked