4

How complier treats inline functions over macros to reduce execution time?

Improve this question
5
  • 3
    This is a premature optimization that you should not care about. Functions are safer for a whole bunch of reasons. Also functions are only inlined if the compiler decides that is a good idea (as usually a human choice to inline is the wrong choice now (or potentially later after the function is maintained)). It is the compiler job to make stuff fast (you just hamper the compiler from doing its job when you try and prematurely optimize stuff). Commented Jan 21, 2011 at 17:02
  • Can you please explain what is premature optimization? Commented Jan 21, 2011 at 17:09
  • 1
    Please read this link. en.wikipedia.org/wiki/Inline_function#Comparison_with_macros Commented Jan 21, 2011 at 17:10
  • 2
    "premature optimization" You are trying to optimize the code by applying a specialized technique. Rather than just writing the code as clearly and concisely as possible. There is normally no point in thinking about these kind of optimizations until you have completed the program and timed the different parts to find the bottleneck. The fact the compiler already does this kind of optimization is another strike against this type of optimization as a human will never be able to beat the compiler (in the long run). Commented Jan 21, 2011 at 17:12
  • @Martin York I wish all of SO would read your comment. The "premature optimization" quote is thrown aronund too often here. There's a difference between good planning for obvious scalability and maintainability problems and worrying about unpredictable things. Your use of the phrase in this instance is spot-on and a good representation of what Knuth meant, I am sure. Commented Jan 21, 2011 at 17:32

8 Answers 8

Reset to default
10

The compiler is also allowed to not inline the function if doing so would be faster, whereas the compiler cannot not inline a macro. In addition, inline functions are miles safer than macros.

Improve this answer
Sign up to request clarification or add additional context in comments.

Comments

1

Inline functions are very similar to macros because they both are expanded at compile time, but the macros are expanded by the preprocessor, while inline functions are parsed by the compiler.

Improve this answer

Comments

1

The most important thing to note here is that a macro is pure text substitution that is done by the preprocessor. The compiler(after preprocessing step) does not know or care what a macro is.

Example:

//this: #define PRINT(s) std::cout << s; int main(int, char**) { PRINT("hello world") return 0; } //Will have identical codegen(in the same compiler version of course) to this: int main(int, char**) { std::cout << "hello world"; return 0; }

For inline functions however, the compiler knows when a call to a function is inlined, and it has much more contextual information about the usage of it. This also means, as other people have mentioned, that it is a request. If the compiler deems that inlining the function is more harmful, then it will leave it as a regular function call. In contrast of macros, the compiler will have no information about code repetition when using a macro.

In summary, if your code can be using an inlined function, then use that instead of a macro. You are helping the compiler make your code better by providing it with more information.

Improve this answer

Comments

1

And also, MACROS have no access to the class member variables. It doesn't understand scoping. Here, inline functions come useful.

Improve this answer

Comments

0

There should be no speed difference (assuming reasonable small code), because they both will get compiled into the place where they were used/called. Its just better practice to use functions, because macros can have a way of doing unforseen things.

Improve this answer

7 Comments

Worth noting that marking a function inline doesn't guarantee it will be - it's a "request" rather than an instruction. In this case there will be the (small) function call overhead. Totally agree about using them in preference to macros - you get type safety and fewer side-effects in the parameter lists
@Kev: But there is also a cost of actually inlining. If the function is large this will cause more page faults (as the program will be larger) as the program is loaded resulting in slower execution. So you have to way the cost of a function call against the cost of extra page faults (and a million other things). Thus in-lining does not necessarily make the code faster.
@Martin York This is not a discussion of whether to inline a function or not. It is whether to use a macro or function. If both do the same thing, hence are the same size, then using the function will at worst be the same size as the one with the macro.
@Martin. You're absolutely right but I wasn't actually saying it would be faster. My comment was mainly to warn that an inline function might not actually be inlined in the generated code. For your argument about extra code, that applies equally to macros of course. Bottom line is that if anything's performance-related and you care, measure the options
@gamernb: You are missing the point. Macros can't become functions, so the compiler has to put them inline. functions can be inlined at the compilers choice. If you remove the choice from the compiler you will ultimately end up with slower code (the compiler will ultimately always make a good choice so don't take the choice away from the compiler).
|
0

Inline functions follow all the protocols of type safety enforced on normal functions.

Inline functions are specified using the same syntax as any other function except that they include the inline keyword in the function declaration.

Expressions passed as arguments to inline functions are evaluated once. In some cases, expressions passed as arguments to macros can be evaluated more than once.

Another thing to keep in mind is that macros are expanded at pre-compile time, so you cannot use them for debugging. For inline functions, however, this is not the case.

scope is globle in case of macro, local scope can be applied to inline function.

Improve this answer

Comments

0 
 Inline Function Macros
  1. Inline function are parsed by the compiler | 1. macros are processed by preprocessor.
  2. inline function can be written inside | 2. macros cannot be written inside. the class. |
  3. inline performed strick type checking | 3. macros does not perform strict cheking.
  4. inline function are proceed by the keyword. | 4. where is macros are proceed by #include | ,define.
  5. inline function containing argument are | 5. macros containing expression have to be processed once and then can be used many | processed every time they are used. time. |
Improve this answer

Comments

0

inline functions are far better than macros . for example if inline function is large enough to slow the execution speed of the code, compiler does not makes it inline where as there is no such check on macros

Improve this answer

Comments

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.