Inline functions vs Preprocessor macros

Preprocessor macros are just substitution patterns applied to your code. They can be used almost anywhere in your code because they are replaced with their expansions before any compilation starts.

Inline functions are actual functions whose body is directly injected into their call site. They can only be used where a function call is appropriate.

Now, as far as using macros vs. inline functions in a function-like context, be advised that:

• Macros are not type safe, and can be expanded regardless of whether they are syntatically correct - the compile phase will report errors resulting from macro expansion problems.
• Macros can be used in context where you don't expect, resulting in problems
• Macros are more flexible, in that they can expand other macros - whereas inline functions don't necessarily do this.
• Macros can result in side effects because of their expansion, since the input expressions are copied wherever they appear in the pattern.
• Inline function are not always guaranteed to be inlined - some compilers only do this in release builds, or when they are specifically configured to do so. Also, in some cases inlining may not be possible.
• Inline functions can provide scope for variables (particularly static ones), preprocessor macros can only do this in code blocks {...}, and static variables will not behave exactly the same way.

First, the preprocessor macros are just "copy paste" in the code before the compilation. So there is no type checking, and some side effects can appear

For example, if you want to compare 2 values:

#define max(a,b) ((a<b)?b:a)

The side effects appear if you use max(a++,b++) for example (a or b will be incremented twice).Instead, use (for example)

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

The Inline function are expanded by the compiler where as the macros are expanded by the Preprocessor, which is mere textual substitution.Hence

• There is no type checking during macro invocation while type checking is done during function call.

• Undesired results and inefficiency may occur during macro expansion due to reevaluation of arguments and order of operations. For example

  #define MAX(a,b) ((a)>(b) ? (a) : (b))int i = 5, j = MAX(i++, 0);

  would result in

  int i = 5, j = ((i++)>(0) ? (i++) : (0));

• The macro arguments are not evaluated before macro expansion

  #define MUL(a, b) a*bint main(){  // The macro is expended as 2 + 3 * 3 + 5, not as 5*8  printf("%d", MUL(2+3, 3+5)); return 0;}// Output: 16`

• The return keyword cannot be used in macros to return values as in the case of functions.

• Inline functions can be overloaded

• The tokens passed to macros can be concatenated using operator ## called Token-Pasting operator .

• Macros are generally used for code reuse where as inline functions are used to eliminate the time overhead (excess time) during function call(avoiding a jump to a subroutine).