C++ Inline function
A C++ function that extends in line when called is known as an inline function. It reduces function call overhead by having the compiler use the function code rather than the function call. It can enhance performance, particularly for little and frequently mentioned activities.
Syntax Containing Code:
#include <iostream>
inline int square(int x) {
return x * x;
}
int main() {
std::cout << "Square of 5: " << square(5) << std::endl;
return 0;
}
When to use inline functions:
- Use inline functions for short, frequently used functions (like getters, setters, or utility functions).
- Inline functions should not be used for large functions, loops, recursion, or complex logic.
Algorithm:
Below is the step-by-step points for the inline function algorithm
-
Start
-
Define an inline function with the inline keyword.
-
The function takes an integer parameter and returns its square.
-
Call the inline function from main(), passing an integer argument.
-
The compiler replaces the function call with the actual function definition.
-
Display the result.
-
End.
Pseudo code:
Pseudo code for inline function for square function:
BEGIN
DEFINE INLINE FUNCTION square(x)
RETURN x * x
END FUNCTION
BEGIN MAIN
DECLARE num ← 5
DECLARE result ← square(num)
PRINT "Square of", num, ":", result
END MAIN
END
Explanation:
- The definition of the function square(x) is added at the call site without a function call because it is marked as inline.
- The program initializes an integer num with a value (e.g., 5).
- The square() function is called, calculating and returning x * x.
- The result is printed on the console.
Example 1:
Let us take an example using multiple Inline Functions for square, cube and Doubling a number in C++.
#include <iostream>
// Inline function to calculate square
inline int square(int x) {
return x * x;
}
// Inline function to calculate cube
inline int cube(int x) {
return x * x * x;
}
// Inline function to double a number
inline int doubleNumber(int x) {
return x * 2;
}
int main() {
int num = 4;
// Calling inline functions
std::cout << "Square of " << num << " is: " << square(num) << std::endl;
std::cout << "Cube of " << num << " is: " << cube(num) << std::endl;
std::cout << "Double of " << num << " is: " << doubleNumber(num) << std::endl;
return 0;
}
Output:
Square of 4 is: 16 Cube of 4 is: 64 Double of 4 is: 8
Example 2:
Let us take an example to illustrate the Inline function inside a class in C++.
#include <iostream>
class MathOperations {
public:
// Inline function to calculate square
inline int square(int x) {
return x * x;
}
// Inline function to calculate cube
inline int cube(int x) {
return x * x * x;
}
// Inline function to find the maximum of two numbers
inline int max(int a, int b) {
return (a > b) ? a : b;
}
};
int main() {
MathOperations math; // Creating an object of the class
int num1 = 3, num2 = 5;
// Calling inline functions
std::cout << "Square of " << num1 << " is: " << math.square(num1) << std::endl;
std::cout << "Cube of " << num1 << " is: " << math.cube(num1) << std::endl;
std::cout << "Maximum of " << num1 << " and " << num2 << " is: " << math.max(num1, num2) << std::endl;
return 0;
}
Output:
Square of 3 is: 9 Cube of 3 is: 27 Maximum of 3 and 5 is: 5
Advantages of Inline Function:
Several advantages of the inline function in C++ are as follows:
- Reduces Function Call Overhead: Since the function code is inserted straight into the calling location, there is no need for a function call or the pushing and popping of registers.
- Faster Execution: Inline expansion can lead to faster execution for small routines.
- Better Code Optimization: The compiler can optimize inline functions more effectively because it has access to the entire function definition.
Disadvantages of Inline Function:
Several disadvantages of the inline function in C++ are as follows:
- Code Duplication: A large inline function, which is called repeatedly, causes more code duplication and a greater binary size.
- Compiler Dependency: If a function is too complicated, probably the compiler will ignore the inline keyword, which is just a hint.
- Slower Compilation: The compilation time is increased when inline functions are expanded repeatedly.
Conclusion:
In conclusion, C++’s robust inline functions eliminate the overhead of function calls because the function body is a part of the compilation. In general terms, this method maximizes output and minimizes execution time, especially for small, routine tasks. Inline functions should be used sparingly since they can expand the code and increase binary files, particularly when dealing with complex or large routines. Ultimately the decision of inline function usage will be determined by optimization flags and the compiler itself. When used appropriately, inline functions can enhance output considerably without damaging code structure or readability.