What is the difference between macro and inline function in c plus plus?

Answer 1

Macros are not actually part of the C++ language; they are nothing more than a simple text-replacement system intended to simplify your coding. Macros do not adhere to C++ type safety and cannot be debugged because macros are preprocessed, prior to compilation. Your compiler can only see the preprocessed code, not the original source code, and therefore cannot debug macros because the macros no longer exist at that point.

Inline functions are functions that can be debugged like any other function, but the compiler is able to eliminate the overhead of function calla by replacing those calls with inline expanded code. This is not unlike a macro, which is by definition inline expanded, but retains the built-in type safety and debugging capabilities of the C++ language itself.

Typically, if you can use an inline function (or C++ is general) then that is always the preferred option. But if a macro can achieve more than can be achieved with C++ alone, or can otherwise simplify the equivalent C++ code, then use a macro. Just keep in mind that macros are not type-safe and cannot be debugged by the C++ compiler.

Answer 2

Preprocessor macros are a text substitution pattern that is applied throughout your code prior to compilation. Inline functions are actual functions that are inline expanded, replacing every call to those functions with inline code. But while macros can be used to simulate inline expansion, it is never recommended.

The compiler performs an enormous amount of analysis during pre-compilation in order to produce the most efficient code possible. While inline expansion will certainly produce a faster function (by eliminating the function call altogether) it is at the expanse of code size, which will reduce the overall performance of your code. However, the inline keyword is merely a hint to the compiler that a function is a candidate for inline expansion, nothing more -- it is free to ignore the request. Compilation flags give you a certain degree of control over how much expansion is actually applied, but ultimately the compiler decides what is best.

Macro substitution effectively bypasses the compiler and expands functions whether it is desirable or not. While you will certainly gain full control over expansions, macros are not type-safe. Substitution may result in contextual errors or unexpected side-effects. Static variables are also handled differently. And while compile-time errors are fairly easy to deal with, runtime errors within macros are more difficult to track down. Macros may also result in unexpected function overloads that would be far better handled with inline template functions, which naturally enlists the compiler's wealth of analysis.

Ultimately, the compiler is there to assist you, so it makes sense to enlist it as much as possible. If there is a choice between a macro and an inline function, go with the inline function every time.

It should be noted that recursive functions cannot be inline expanded nor macro substituted, for obvious reasons.