Inline Function In C++| Syntax, Uses, Working & More (+ Examples)

An inline function in C++ programming is a special type of function defined using the inline keyword. Instead of making a traditional call where control is passed to the function and then returned, an inline function's code is directly inserted into the place where the function is called. This can speed up execution by eliminating the overhead associated with function calls.

In this article, we'll explore the concept of inline functions, examining how they work, their benefits, and the situations where they might not be as effective. We'll also discuss how to declare inline functions, the limitations imposed by the compiler, and best practices for using them in your C++ programs.

What Is An Inline Function In C++?

The inline function in C++ programming is a function for which the compiler is requested to insert the function's code directly at the location where the function is called, rather than performing a traditional function call. This approach reduces the overhead associated with function calls, such as stack operations and branching, potentially speeding up execution.

We use the inline keyword to suggest this behavior, though it is ultimately up to the compiler to decide whether or not to inline the function. Inline functions are particularly useful for small, frequently called functions, as they can help minimize the performance cost of function invocation. One of the main advantages of the inline function in C++ is that it can also be used with C++ classes.

Syntax For Defining An Inline Function In C++:

inline data_type function_name(Parameters) {
//actual function code
}

Here,

• inline: This keyword suggests to the compiler to insert the function's code directly where it's called.
• data_type: It specifies the return type of the function.
• function_name: It is the name used to call the function.
• Parameters: List of parameters the function takes (can be empty if there are no parameters).

How To Define The Inline Function In C++?

As discussed in the syntax above, an inline function in C++ is declared using the inline keyword, and its definition must typically be placed near the declaration. The process for defining an inline function in C++ is as follows:

1. Declaration/Definition Location: An inline function is often declared and defined at the beginning of the structure of C++ program, but it can also be defined inside a class or a structure.
2. Function Call: After the function is declared, it can be called from other parts of the program. During compilation, the compiler attempts to replace the function call with the inline function's code, potentially reducing the overhead associated with a standard function call.

In other words, an inline function is declared and defined like a regular function but with the inline keyword. The function definition can be located at the beginning of the program or within a class or structure (we will discuss this in more detail in a later section). The example below showcases the implementation of an inline function in C++.

Code Example:

#include<iostream>

using namespace std;

// Use the keyword "inline" to define an inline function
inline int sum(int a, int b) {
// Definition of inline function
return a + b;
}

int main() {
int a = 10, b = 30;
int result = sum(a, b); // Function call to inline function

// Compiler replaces sum() with the inline function definition.
cout << "The inline function sum() returned: " << result << endl;

return 0;
}

Output:

The inline function sum() returned: 40

Explanation:

In the simple C++ program, we begin by including the essential header file <iostream> for input-output operations and use namespace to avoid prefixing std:: to standard library functions.

1. Then, we define a function called sum() with the inline keyword, indicating that sum() is an inline function.
2. The function takes two integer variables a and b as input and returns their total which is calculated using the addition arithmetic operator.
3. Note that when a call is made to this inline function sum(), the compiler replaces the function call with the actual code of the inline function, i.e., return a + b.
4. In the main() function, we declare and initialize variables a and b with the values 10 and 30, respectively.
5. We then call the sum() function, passing a and b as arguments, and store the result in the variable result.
6. As mentioned in the code comments, the compiler replaces the sum() function with the internal definition in the code line itself.
7. We then use the cout command to print the value of the result variable.
8. Finally, the main() function terminates with a return 0 statement indicating successful execution to the operating system.

How Does Inline Function In C++ Work?

Before discussing the working mechanism of an inline function in C++, let's take a peek into the workings of a normal C++ function.

1. When a function call is encountered during program execution, the CPU first stores the memory address of the instruction following the function call.
2. It then copies the function arguments onto the stack and transfers control to the called function.
3. The CPU executes the code within the called function, and the return value is stored in a specified memory location or register.
4. Control is then transferred back to the calling function.

This process introduces overhead of function calls, especially when the execution time of the called function is shorter than the time needed to transfer control to and from the called and calling functions.

Now, in the case of an inline function in C++, when a function call is encountered, the CPU performs various steps:

1. When an inline function is called, the compiler substitutes the entire function code directly in place of the function call during compile time. (This is why it's called an "inline" function.)
2. There is no control transfer between functions, as the function code is already in place. Therefore, the CPU executes the code directly, and the control jumps to the next line after the inlined code.

By eliminating the overhead associated with function calls, inline functions can improve program performance, especially in cases where the function is called frequently.

The Need For An Inline Function In C++

Inline functions in C++ can be very useful in specific scenarios. Here’s why we might need them:

1. Reduction of Function Call Overhead: When a function is called, the overhead includes storing the memory address, passing arguments, and managing return values. For small functions that are called frequently, this overhead can become significant. Inline functions in C++ eliminate this overhead by embedding the function code directly into the caller’s code, reducing the time and memory required for function calls.

2. Increased Execution Speed: By replacing function calls with the actual code of the function, inline functions in C++ can lead to faster execution. This is particularly advantageous in performance-critical sections of code where the function performs simple operations.

3. Compile-Time Code Expansion: The function code for inline functions in C++ is expanded at compile time, not at runtime. This means that the code is inserted directly into the calling code before the program is run, leading to potential improvements in execution speed and efficiency.

Can The Compiler Ignore/ Reject Inline Function In C++ Programs?

In C++ programming language, when we declare a function as inline, we suggest to the compiler that it should replace each function call instruction with the function's code, thereby reducing the overhead associated with function calls.

However, it is important to note that the keyword inline is merely a request or suggestion to the compiler, not a command. The compiler has the final say in whether or not to actually inline the function. Here are some situations where the compiler might choose to ignore or reject the request to inline a function in C++ programs:

• If an inline function contains a return statement but doesn’t return anything, the compiler declines the inline call/ request to inline the function.
• A compiler does not consider the request to inline a function if it is recursive.
• Functions containing one or more static variables are not considered an inline functions by the C++ compiler.
• A compiler denies the request to inline a function in C++ if it contains a go-to or a switch statement.
• If a function contains any kind of loop statement, the compiler will deny the request for inlining the function.

Normal Function Vs. Inline Function In C++

The normal function and the inline function in C++ both encapsulate a piece of code to be reused throughout the program. While the basic purpose for both function types might be the same, there are some prominent differences between the two. 

The table below highlights the key differences between normal and inline function in C++ programming.

Let's look at a code example to understand how normal function differs from inline function in C++:

Code Example:

#include <iostream>

using namespace std;

// Normal function definition
int normalAdd(int a, int b) {
return a + b;
}

// Inline function definition
inline int inlineAdd(int a, int b) {
return a + b;
}

int main() {
int x = 5, y = 10;

// Using the normal function
int normalResult = normalAdd(x, y);
cout << "Result using normal function: " << normalResult << endl;

// Using the inline function
int inlineResult = inlineAdd(x, y);
cout << "Result using inline function: " << inlineResult << endl;

return 0;
}

Output:

Result using normal function: 15
Result using inline function: 15

Explanation:

In the above code example-

1. We start by defining a normal function called normalAdd(). This function takes two integer parameters, a and b, and returns their sum. This function is called a normal function because it involves the overhead of a function call each time it is invoked.
2. We also define an inline function named inlineAdd(). Similar to normalAdd(), it takes two integer parameters and returns their sum. However, by using the inline keyword, we suggest to the compiler that it should try to replace the function call with the function's code directly. 
3. Next, inside the main() function, we declare two integer variables, x and y, and initialize them with values 5 and 10, respectively.
4. We then call normalAdd() with x and y as arguments and store the result in normalResult. We use cout to print the result to the console.
5. We follow a similar process for the inlineAdd() function. We call it with x and y as arguments, store the result in inlineResult, and print it to the console.

Classes & Inline Function In C++

Inline functions in C++ can be used within class definitions to enhance performance, particularly for small, frequently used member functions. When a member function of a class is declared inline, the compiler may choose to replace the function call with the function’s code directly at the call site. 

Syntax:

class Class_name {
access_specifier:
int Func_name (int variable); // declaring the function inside the class
};
inline int Class_name:: Func_name (int variable) // use inline keyword to define inline function{
//inline function body
}

Here,

• The class keyword is used to create a class whose name is given by Class_name.
• Access_specifier indicates the visibility mode of the elements inside the class. This can be private, protected, or public.
• The inline keyword indicates that the function with the name Func_name is an inline function.

Code Example:

// C++ Program to design a calculator using inline function and class

#include <iostream>
using namespace std;

class calculate {
int x, y, sum, diff, mul;
float div;

public:
// Inline functions declared
void get_input();
void add();
void subtract();
void multiply();
void divide();
};

// Inline function definitions
inline void calculate::get_input() {
cout << "Enter the first value: ";
cin >> x;
cout << "Enter the second value: ";
cin >> y;
}

inline void calculate::add() {
sum = x + y;
cout << "The sum of two numbers: " << sum << "\n";
}

inline void calculate::subtract() {
diff = x - y;
cout << "Difference between two numbers: " << diff << "\n";
}

inline void calculate::multiply() {
mul = x * y;
cout << "Product of two numbers: " << mul << "\n";
}

inline void calculate::divide() {
div = x / (y * 1.0);
cout << "Division of two numbers: " << div << "\n";
}

int main() {
cout << "Calculator using inline functions\n";

calculate c;
c.get_input();
c.add();
c.subtract();
c.multiply();
c.divide();

return 0;
}

Output:

Calculator using inline function
Enter the first value:25
Enter the second value:4
The sum of two numbers: 29
Difference between two numbers: 21
Product of two numbers: 100
Division of two numbers: 6.25

Explanation:

In the above C++ executable code,

1. We define a class named calculate. This class contains private data members to store the two integer values x and y, as well as the results of various mathematical operations used in the code.
2. In the public section of the class, we declare five member functions. All these functions are defined as inline functions using the inline keyword. They are intended to handle various calculator operations:
   • get_input() to read the values for x and y.
   • add() to calculate and display the sum of x and y.
   • subtract() to calculate and display the difference between x and y.
   • multiply() to calculate and display the product of x and y.
   • divide() to calculate and display the result of dividing x by y.
3. The get_input() function prompts the user to enter two integer values, which are then stored in x and y. The add() function calculates the sum of x and y and prints it.
4. Similarly, the subtract() function computes the difference, the multiply() function calculates the product, and the divide() function performs division, ensuring to cast y to float to handle division correctly and avoid integer division issues.
5. In the main() function, we first print a message indicating that we are using a calculator with inline functions.
6. We then create an object c of the calculate class. We call the get_input() function to read the values, and then sequentially call add(), subtract(), multiply(), and divide() to perform and display the results of these operations.

Understanding Inline, __inline, And __forceinline Functions In C++

The inline() and __inline() are both variations of inline functions in C++. These keywords signal to the compiler that the function code must be inserted at the function call during compilation. However, it is up to the compiler whether to accept this request or not based on efficiency. If inlining does not make the program efficient, it may reject the request or vice versa.

On the other hand, the __forceinline keyword explicitly instructs or forces the compiler to inline the function even if the compiler analyses it to be inefficient. Even though the compiler is forced to inline a function, there are some rare scenarios in which the inlining may not occur. Let's look into these keywords in more detail.

Inline Function In C++

Inline is a standard C++ keyword used to suggest that the compiler expand the function inline. However, the compiler has the final say on whether to actually inline the function.

• The decision is typically based on various factors, such as the size of the function and optimization settings.
• The main purpose of using inline is to optimize small, frequently called functions by inserting their code directly at the call site, thereby avoiding the overhead of a function call.
• It is recommended to use inline for functions that are short and likely to be called frequently.

Syntax:

inline returnType functionName(Parameters) {
//code
}

The __inline Function In C++

The _inline is an older, non-standard extension used by some older Microsoft compilers like Visual C++ 6.0.

• It serves a similar purpose to the standard inline keyword, suggesting the compiler consider the inline expansion of a function.
• In modern Microsoft compilers, like Visual C++ from Visual Studio 2015 onwards, _inline is typically treated as synonymous with inline.
• This means that using _inline in newer code will usually have the same effect as using inline. The compiler will decide whether to inline the function based on the standard rules and optimizations.

Syntax:

_ _inline returnType functionName(Parameters) {
//code
}

The __forceinline Function In C

The _forceinline is a Microsoft-specific extension that provides a more directive approach to inline expansion.

• When a function is marked with _forceinline, the compiler is forcefully instructed to inline the function, overriding the usual decision-making process.
• Unlike inline or _inline, which are suggestions to the compiler, _forceinline is a strong directive. The compiler is almost guaranteed to inline the function at every call site, regardless of its size or other optimization settings.
• The main advantage of using _forceinline is that it allows developers to explicitly ensure that a function is always inlined, which can lead to performance improvements in some cases.
• However, it can also result in larger binary sizes due to code duplication at each call site, which might not be desirable.

Syntax:

__forceinline returnType functionName(Parameters) {
//code
}

Inline Vs. _Inline Vs. _forceline In C++

When To Use An Inline Function In C++?

We have seen the use of inline functions and how they help increase the overall program performance. However, there are some cases where we should prefer using these functions to take advantage of the advantages of inline functions in C++. The cases are :

• Small and Frequently Called Functions: Inline functions are ideal for small functions that are called frequently. These functions typically have a short body and perform simple operations. For Example-

inline int add(int x, int y) {
return x + y; // Simple, small function
}

• Performance-Critical Code: We can utilize the inline function in C++ when performance is a critical concern and the function is small and performance-sensitive. For Example-

inline double square(double x) {
return x * x; // Simple mathematical operation
}

• Accessor and Mutator Functions: Inline functions are useful for getter and setter functions in classes (accessors and mutators). For Example-

class Rectangle {
private:
int width;
int height;
public:
inline int getWidth() const { return width; }
inline void setWidth(int w) { width = w; }
};

• Template Functions: Templates are typically defined in executable files(header) and are instantiated in different compilation units. Inline functions in templates help avoid multiple definition issues and improve efficiency. For Example-

template <typename T>
inline T max(T a, T b) {
return (a > b) ? a : b;
}

• Constexpr Functions: Functions declared with constexpr are evaluated at compile time. Inlining constexpr functions can further optimize compile-time calculations. For Example-

constexpr int factorial(int n) {
return (n <= 1) ? 1 : n * factorial(n - 1);
}

• Avoiding Function Call Overhead: Inline function in C++ avoids the overhead of a function call by embedding the function code directly at each call site. For Example-

inline int multiply(int a, int b) {
return a * b; // Simple multiplication function
}

Advantages Of Inline Function In C++

We prefer to use an inline function to increase the performance of a program over normal functions. Listed below are the advantages of the inline function in C++

• Reduced Function Call Overhead: Inline function in C++ eliminates the overhead associated with function calls, such as saving the return address, passing arguments, and transferring control. By substituting the function code directly at the call site, the program can execute more efficiently, particularly for small, frequently called functions.

• Faster Execution: Since the inline functions in C++ avoid the function call mechanism, a program's execution speed can improve, especially in performance-critical sections where the same small function is called repeatedly.

• Enhanced Code Optimization: The compiler can better optimize inlined code because it has more context about how the function is used. For example, the compiler might be able to eliminate unnecessary calculations or combine operations more effectively.

• Improved Code Readability: Inline functions in C++ help make the code cleaner and more readable by encapsulating repeated code into a single function. This avoids the clutter of repeating the same code block multiple times and keeps the logic in one place.

• Better Use of Inline Functions in Classes: Inline functions in C++ can be particularly useful in classes, where they are often defined directly inside the class definition. This makes the class interface more concise and easier to understand.

• Reduced Function Call Stack Size: Since inline functions do not involve traditional function calls, the call stack size can be reduced, which is beneficial in environments with limited stack memory.

• Enforced by the Compiler: The compiler decides whether to inline a function based on its internal heuristics, which ensures that only functions that benefit from inlining are actually inlined. This helps maintain a balance between performance and code size.

• Avoidance of Function Call Penalties in Recursion: Although recursive functions cannot be inlined directly, using an inline function in C++ in conjunction with loop unrolling techniques can help mitigate some function call penalties in scenarios where inlining is feasible.

Disadvantages Of Inline Function In C++

Although there are many advantages to inline functions in C++, there are also some disadvantages that should be taken care of. They are:

• Increased Code Size (Code Bloat): Since inline functions in C++ involve replacing the function call with the actual function code at each call site, this can lead to an increase in the size of the compiled binary, especially if the function is large or called frequently. This is known as code bloat and can negatively impact programs with limited cache memory spaces.

• Longer Compilation Time: Inline functions in C++ programs can increase compilation time because the compiler must insert and optimize the function code at each call site. For large projects with many inline functions, this can slow down the build process.

• Limited Functionality: Not all functions are suitable for inlining. Functions that are too complex, contain loops, recursion, or have many branches may not be inlined by the compiler. Additionally, functions that rely on dynamic linking cannot be inlined because their code must remain in a separate binary.

• Compiler Dependency: The actual inlining of a function is ultimately decided by the compiler. Even if a function is declared with the inline keyword, the compiler may choose not to inline it if it determines that doing so would not be beneficial or could degrade performance. This can lead to inconsistent behavior across different compilers or compiler settings.

• Potential for Debugging Difficulties: Inlined code can make debugging more challenging because the function call is replaced with the actual code in the compiled binary. This can make it harder to trace function calls or to set breakpoints effectively, as the inlined code may not appear as a distinct function in the debugger.

• Increased Cache Usage: The larger binary size resulting from inlined functions can lead to more cache misses, as more code needs to fit into the CPU's instruction cache. This can potentially degrade performance, especially in systems with limited cache sizes.

• Decreased Modularity: Inline functions in C++ can reduce code modularity since changes to the inline function require recompilation of all translation units where the function is inlined. This can complicate maintenance and increase the chances of introducing bugs when making changes.

Why Not Use Macros Instead Of An Inline Function In C++?

Macros are similar to inline functions in C++ as the function code for both is expanded when the function is called during compile time. Macros are preprocessor directives allowing for text substitution in code and are typically used for creating shorthand notations or code generation.

However, there are a few shortcomings of preprocessor macros that tip the scales in favor of inline functions in C++. These are:

• Macros can not access private class members: This inhibits their ability to encapsulate data and thereby compromises data privacy.
• Macros lack type checking: This can lead to errors and unexpected results since the compiler does not validate the argument type sent to macros.
• Error-prone nature: They are mostly never necessary or required and are error-prone, as stated by the creator of C++ - Bjarne Stroustrup.
• Inlining restriction: The functions defined in a class are implicitly inline. A virtual function can not be inlined since it is executed at runtime, and inlining occurs at compile time.

Macros Vs. Inline Functions In C++

Here are some of the key differences between macros and inline functions in C++:

Conclusion

Inline function in C++ programming is a powerful feature that offers significant performance benefits by reducing the overhead associated with function calls. By embedding the function code directly at the call site, inline functions can optimize execution time, particularly for small, frequently called functions. They enhance performance-critical sections of code, simplify debugging, and improve code readability and maintainability.

However, it is important to use inline functions judiciously. While they can provide substantial gains in execution speed and efficiency, excessive use or misuse can lead to code bloat and increased compilation times. By carefully balancing performance optimizations with code clarity and maintainability, developers can harness the power of inline functions to create efficient and high-performing C++ applications.

Frequently Asked Questions

Q. Are static member functions inline in C++?

A static member function can be converted to an inline function in C++ using the inline keyword as a prefix. Inlining static functions suggests the compiler to replace the function call with function code during compilation. This can improve the performance since the static function execution time is less than the time required for control transfer from the calling function to the called function.

Q. What is the advantage of inline function over macro in C++?

Advantages of inline function over macro in C++:

• Type-Compatibility: The inline function in C++ is checked for data type computability with the input arguments, but the macro functions are not, which may result in undesirable results or code failure.
• Debugging and error reporting: Inline functions provide better error reports and easier debugging compared to macros in C++.
• Privacy: Macros are not reliable since they cannot access private data members and, therefore, are at risk of data breach.

Q. What is the inline function and virtual function in C++?

An inline function in C++ is a special type of function that the compiler attempts to expand in place. This means that wherever the function is called, the compiler replaces the function call with the actual code of the function. This reduces the overhead associated with a function call, such as pushing arguments to the stack and jumping to the function's location in memory.

Syntax:

inline int add(int a, int b) {
return a + b;
}

A virtual function in C++ is a function in a base class that can be overridden in derived classes. The key feature of virtual functions is that they enable polymorphism, allowing a derived class to provide a specific implementation of a function that is already defined in its base class.

Syntax:

class Base {
public:
virtual void show() {
cout << "Base class show function" << endl;
}
};

class Derived : public Base {
public:
void show() override {
cout << "Derived class show function" << endl;
}
};

Q. Can the compiler ignore the inline keyword?

Yes, the compiler can choose to ignore the inline keyword if it determines that inlining the function would not be efficient. For instance, the compiler may ignore inlining if the function is too complex, contains loops, or is recursive.

Q. When should you avoid using an inline function in C++?

You should avoid using inline functions for large, complex functions that involve loops or recursion and in scenarios where code size (code bloat) is a concern. In such cases, the drawbacks may outweigh the potential performance gains of using an inline function in C++.

Test Your Skills: Quiz Time

You might also be interested in reading the following:

1. Friend Function In C++ | Class, Types, Uses & More (+Examples)
2. OOPs Concept In C++ | A Detailed Guide With Codes & Explanations
3. Dynamic Memory Allocation In C++ Explained In Detail (With Examples)
4. Constant In C++ | Literals, Objects, Functions & More (+Examples)
5. C++ If-Else | All Conditional Statements Explained With Examples