{"id":5021,"date":"2016-11-07T16:10:16","date_gmt":"2016-11-07T16:10:16","guid":{"rendered":"https:\/\/www.modernescpp.com\/index.php\/inline\/"},"modified":"2023-06-26T12:36:52","modified_gmt":"2023-06-26T12:36:52","slug":"inline","status":"publish","type":"post","link":"https:\/\/www.modernescpp.com\/index.php\/inline\/","title":{"rendered":"inline"},"content":{"rendered":"

Thanks to inline<\/span>, the compiler can replace the function call with the function body. There are two reasons to use inline<\/span> functions: performance and safety.<\/p>\n

<\/p>\n

 <\/p>\n

My primary goal was to write this post about performance. Fortunately, a further significant benefit of inline came to my mind. inline<\/span> makes macros a function replacement superfluous.<\/p>\n

Macro must go<\/h2>\n

Macros are only the poor man’s means to replace text. Macros have no understanding of the C++ syntax. Therefore, a lot can go wrong.<\/p>\n

<\/p>\n

\n\n\n\n
\n
 1\r\n 2\r\n 3\r\n 4\r\n 5\r\n 6\r\n 7\r\n 8\r\n 9\r\n10\r\n11\r\n12\r\n13\r\n14\r\n15\r\n16\r\n17\r\n18\r\n19\r\n20\r\n21\r\n22\r\n23\r\n24\r\n25\r\n26\r\n27\r\n28\r\n29\r\n30\r\n31\r\n32\r\n33\r\n34\r\n35<\/pre>\n<\/td>\n
\n
\/\/ macro.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\n#define  absMacro(i) ( (i) >= 0 ? (i) : -(i) )<\/span>\r\n\r\ninline<\/span> int<\/span> absFunction(int<\/span> i){\r\n  return<\/span> i >= 0 ? i : -i;\r\n}\r\n\r\nint<\/span> func(){ \r\n  std::cout << \"func called\"<\/span> << std::endl;\r\n  return<\/span> 0;\r\n}\r\n\r\n\r\nint<\/span> main(){\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  auto<\/span> i(0);\r\n  auto<\/span> res = absMacro(++i);   \r\n  std::cout << \"res: \"<\/span> << res << std::endl;\r\n  absMacro(func());\r\n  \r\n  std::cout << std::endl;\r\n  \r\n  i=0;\r\n  res= absFunction(++i);     \r\n  std::cout << \"res: \"<\/span> << res << std::endl;\r\n  absFunction(func());\r\n  \r\n  std::cout << std::endl;\r\n  \r\n}\r\n<\/pre>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n<\/div>\n
 <\/p>\n
\"inline\"<\/p>\n
The macro in line 5, as the inline<\/span> function in lines 7 – 9, returns the absolute value of its arguments. I invoke the function with the argument ++i. i<\/span> is 0. The result should be 1. It should be because the macro increments the expression i<\/span> two times. Consequently, the result is 2<\/span> instead of 1.<\/span> The function func<\/span> shows it explicitly. When I use the function func<\/span> as an argument, the function will be invoked two times in the case of the macro but only once in the case of the inline<\/span> function.<\/p>\n
What’s happening if I use an inline<\/span> function?<\/p>\n<\/p>\n
inline<\/h2>\n
At first, all behave not as it seems. The compiler will interpret it only as a recommendation if I declare a function as inline. The compiler is free to ignore my recommendation. But it will also work the other way around. Modern compilers like Microsoft Visual C++, gcc, or clang can inline<\/span> a function if it makes sense from a performance perspective.<\/p>\n
Now I have to write in the conjunctive. We must assume the compiler will accept my recommendation and apply the inline keyword in the exchange<\/span> function.<\/p>\n
<\/p>\n
\n
inline<\/span> void<\/span> exchange(int<\/span>& x, int<\/span>& y){\r\n  int<\/span> temp= x;\r\n  x= y;\r\n  y= temp;\r\n}\r\n<\/pre>\n<\/div>\n
 <\/p>\n
What’s happening at the function invocation?<\/p>\n
<\/p>\n
\n
...\r\nauto<\/span> a(2011);\r\nauto<\/span> b(2014);\r\nexchange(a,b);\r\n...\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The compiler substitutes the function call by the function body.<\/p>\n
<\/p>\n
\n
...\r\nauto<\/span> a(2011);\r\nauto<\/span> b(2014);\r\nint<\/span> temp= a;\r\na= b;\r\nb= temp;\r\n...\r\n<\/pre>\n<\/div>\n
 <\/p>\n
The small example shows the advantages and disadvantages of inline a function.<\/p>\n
Advantages<\/h3>\n