inline, __inline, __forceinline

  • Article

https://msdn.microsoft.com/en-us/library/cx053bca(v=msdn.10) https://msdn.microsoft.com/en-us/library/69hzy453(v=msdn.10)

inline function_declarator;   // C++ Specific

__inline function_declarator;   // Microsoft Specific

__forceinline function_declarator;   // Microsoft Specific

The inline and __inline specifiers instruct the compiler to insert a copy of the function body into each place the function is called. The insertion (called "inline expansion" or "inlining") occurs only if the compiler's cost/benefit analysis show it to be profitable. Inline expansion alleviates the function-call overhead at the potential cost of larger code size.

The __forceinline keyword overrides the cost/benefit analysis and relies on the judgment of the programmer instead. Exercise caution when using __forceinline. Indiscriminate use of __forceinline can result in larger code with only marginal performance gains or, in some cases, even performance losses (due to increased paging of a larger executable, for example).

Using inline functions can make your program faster because they eliminate the overhead associated with function calls. Functions expanded inline are subject to code optimizations not available to normal functions.

The compiler treats the inline expansion options and keywords as suggestions. There is no guarantee that functions will be inlined. You cannot force the compiler to inline a particular function, even with the __forceinline keyword.

The inline keyword is available only in C++. The __inline and __forceinline keywords are available in both C and C++. For compatibility with previous versions, _inline is a synonym for __inline.

The inline keyword tells the compiler that inline expansion is preferred. However, the compiler can create a separate instance of the function (instantiate) and create standard calling linkages instead of inserting the code inline. Two cases where this can happen are:

  • Recursive functions.
  • Functions that are referred to through a pointer elsewhere in the translation unit.

These reasons may interfere with inlining, as may others, at the discretion of the compiler; you should not depend on the inline specifier to cause a function to be inlined.

Note that for a function to be considered as a candidate for inlining, it must use the new-style function definition. Functions that are declared as inline, and that are not class member functions, have internal linkage unless otherwise specified.

As with normal functions, there is no defined order of evaluation of the arguments to an inline function. In fact, it could be different from the order in which the arguments are evaluated when passed using normal function call protocol.

The /Ob compiler optimization option helps to determine whether inline function expansion actually occurs.

Example 1

inline int max( int a , int b )
{
   if( a > b ) return a;
   return b;
}

A class's member functions can be declared inline either by using the inline keyword or by placing the function definition within the class definition.

Example 2

class MyClass
{
public:
   void print() { cout << i << ''; }  // Implicitly inline
private:
   int i;
};

Microsoft Specific

The __inline keyword is equivalent to inline.

Even with __forceinline, the compiler cannot inline code in all circumstances. The compiler cannot inline a function if:

  • The function or its caller is compiled with /Ob0 (the default option for debug builds).
  • The function and the caller use different types of exception handling (C++ exception handling in one, structured exception handling in the other).
  • The function has a variable argument list.
  • The function uses inline assembly, unless compiled with /Og, /Ox, /O1, or /O2.
  • The function returns an unwindable object by value, when compiled with /GX, /EHs, or /EHa.
  • The function receives a copy-constructed object passed by value, when compiled with /-GX, /EHs, or /EHa.
  • The function is recursive and not accompanied by #pragma(inline_recursion, on). With the inline_recursion pragma, recursive functions can be inlined to a depth of eight calls, or as determined by the inline_depth pragma (see below).
  • The function is virtual.
  • The program takes the address of the function.

If the compiler cannot inline a function declared with __forceinline, it generates a level 1 warning (4714).

Recursive functions can be substituted inline to a depth specified by the pragma. After that depth, recursive function calls are treated as calls to an instance of the function. The pragma controls the inline expansion of a function currently under expansion. See the Inline-Function Expansion (/Ob) compiler option for related information.

END Microsoft Specific

See Also

noinline, auto_inline