Inline functions vs Preprocessor macros

by

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.

More Related Contents:

  1. When should I write the keyword ‘inline’ for a function/method?
  2. When to use inline function and when not to use it?
  3. Does it make any sense to use inline keyword with templates?
  4. Can we have recursive macros?
  5. What’s the scope of inline friend functions?
  6. Header guards in C++ and C
  7. Foreach macro on macros arguments
  8. C++ inlining class methods causes undefined reference
  9. c++ inline function?
  10. Construct path for #include directive with macro
  11. How to identify platform/compiler from preprocessor macros?
  12. Escaping a # symbol in a #define macro?
  13. Is #pragma once part of the C++11 standard?
  14. Why do I need double layer of indirection for macros?
  15. what is/are the purpose(s) of inline?
  16. How will i know whether inline function is actually replaced at the place where it is called or not?
  17. How to define a string literal in gcc command line?
  18. What is the difference between a macro and a const in C++?
  19. macro definition containing #include directive
  20. How to generate random variable names in C++ using macros?
  21. Self-unrolling macro loop in C/C++
  22. When to use the inline function and when not to use it?
  23. Confused by squaring macro SQR in c [duplicate]
  24. Is there a way to use C++ preprocessor stringification on variadic macro arguments?
  25. Generate include file name in a macro
  26. How to tame the Windows headers (useful defines)?
  27. C++ format macro / inline ostringstream
  28. Should one never use static inline function?
  29. Expand macro inside string literal
  30. How do I implement no-op macro (or template) in C++?

Leave a Comment