What is the Inline Function in C++

Last Updated on May 18, 2023 by Prepbytes

By using examples, this tutorial will educate us about C++ inline functions and how to utilize them. One of the fundamental components of C++ is the inline function. Let’s first attempt to comprehend why we require inline functions before learning what they are.

Why do we need Inline Function in C++?

When the program executes a function call instruction, the CPU transfers the function’s arguments to the stack, caches the memory address of the instruction that comes next, and then hands control to the desired function. Following this, the CPU executes the function’s logic, stores the return value in a predetermined memory location, and returns control to the calling function. Overhead may be present if the function’s execution time is less than the time needed to transfer control from the calling function to the called function. Small functions incur this expense since their switching time is less than their execution time. The cost of function calls is decreased in C++ using inline functions.

Inline Function in C++

A function that expands inline when it is invoked is known as an inline function. This shortens the process’s duration. By substituting the function call with the appropriate function code, the compiler reduces the cost of function calls. The runtime compiler replaces all of the calling statements with the function definition when an inline function is called. Every time an inline function is called, the compiler duplicates the function’s code in place to prevent a function call.

Circumstances Where the Compiler Does Not Consider Inline Functions

The inline Function does not work for the following situations:

1. When a function has a loop, switch, or goto and returns a value.
2. If there is a return statement for functions that don’t return values.
3. The compiler will refuse to allow the function to be made an inline function if it includes one or more static variables.
4. A recursive function won’t be regarded as an inline function by the compiler.

Declaration of Inline Function in C++

To declare Inline Function in C++, we use the “inline” keyword. For example,

inline return_type function_name(parameters)
{
  //Code
}

Explanation of the Syntax:

• The keyword "inline" is used at the beginning to inform the compiler that the function is an inline function. However, the choice of whether to inline a function or not is left up to the compiler.
• When an inline function is declared, it must also be defined. The compiler will simply replace all instances where the function is called in the program with the definition of the function.

Here is an example of an inline function that returns the maximum of two numbers –

#include <bits/stdc++.h>
using namespace std;

inline int max(int num1, int num2)
{
    return (num1 > num2) ? num1 : num2 ;
}

int main() 
{
	cout<<"max(60,15) : "<<max(60,15)<<endl ;
	cout<<"max(11,30) : "<<max(11,30)<<endl ;
	
	return 0;
}

Output

Max(60,15) : 60
Max(11,30) : 30

Here is how the program works –

Here, we created an inline function named max() that takes two integers as parameters. Then, we made 2 inline function calls inside the main() function with different arguments. Each time max() is reached, the compiler copies the code of the function to that call location.

Use of Inline Function in C++

• The inline function can be used over macros. These functions have an advantage over macros since they are more effective and optimized. Almost all of the capabilities that macros may offer can be obtained by utilizing inline functions.
• Performance-wise, inline functions consistently outperform other methods. Inline functions are the only option if your software requires performance since they speed up the execution of your code.
• By utilizing the inline keyword outside of the class, you may build inline functions to hide the implementation details of your functions.

Advantages of Inline Function in C++

These are some of the advantages of inline function in C++

• Due to the elimination of function call overhead provided by inline functions, the program’s compilation speed is boosted.
• When a function is invoked, the overhead of pushing and popping variables from the stack is also avoided.
• Additionally, it avoids the overhead of a function’s return call.
• They enable the compiler to carry out some content-specific optimizations on the function’s body. Other function calls cannot undergo such optimizations.

Disadvantages of using Inline Function

These are some of the disadvantages of inline function in C++

• Longer inline functions may reduce the cache hit rate of the instructions, therefore they must be kept to a minimum. The effectiveness of the program may suffer as a result.
• Due to the repetition of the same code, using too many inline functions will increase the size of the binary executable file.
• Large inline functions are ineffective for embedded systems since these systems prioritize function size over performance.
• Large functions may result in compilation overhead, which lowers the code’s efficiency.

Conclusion
In conclusion, we have explored the concept of inline functions in C++. We learned that inline functions are a way to optimize function calls by inserting the function code directly at the call site instead of performing a regular function call. This can lead to improved performance by reducing the overhead associated with function calls.

Inline functions are defined using the inline keyword in C++. When a function is declared as inline, the compiler may choose to replace function calls with the actual function code, eliminating the overhead of a function call. However, it’s important to note that the inline keyword is just a suggestion to the compiler, and the compiler has the final decision on whether to inline the function or not.

Inline functions are typically used for small, simple functions that are frequently called. They are commonly used for getter and setter functions, utility functions, and other functions with minimal logic.

FAQs related to Inline Function in C++

Q1: When should I use inline functions?
Ans. Inline functions are most effective when used for small, simple functions that are frequently called. It is recommended to use inline functions for utility functions, getter and setter functions, and other small functions that perform basic operations.

Q2: Are inline functions always faster?
Ans. Inline functions can potentially improve performance by reducing the overhead of function calls. However, it is important to note that the decision to inline a function is ultimately up to the compiler. In some cases, the compiler may choose not to inline the function, depending on factors such as function complexity, optimization settings, and compiler-specific rules. Therefore, it is not guaranteed that using the inline keyword will always result in faster code.

Q3: Can inline functions be recursive?
Ans. No, inline functions cannot be recursive. Recursive functions rely on repeated function calls, which defeats the purpose of inlining. Inline functions should be simple and self-contained, without any recursive calls.

Q4: Can I define an inline function in a separate source file?
Ans. While it is possible to define an inline function in a separate source file, it is not recommended. In order for the function to be inlined, the function definition must be visible to the compiler at the call site. Therefore, it is best practice to define inline functions in header files or within the same source file where they are used.

Q5: Can I use the inline keyword with member functions of a class?
Ans. Yes, the inline keyword can be used with member functions of a class. When defining a member function within the class declaration, it is implicitly inline. However, if the member function is defined outside the class declaration, you can explicitly use the inline keyword to indicate your intention for inlining.

Q6: Are there any downsides to using inline functions?
Ans. While inline functions can provide performance benefits, there are also potential downsides. Inline functions can lead to larger executable sizes if they are heavily used throughout the codebase. Additionally, changes to the inline function’s definition require recompilation of all source files that include the header defining the inline function. Therefore, it’s important to use inline functions judiciously and consider the trade-offs between performance and code size.