Memory preservation is one of the main reasons to use functions in programmes, especially when those functions are likely to be called repeatedly. When a function is called, activities like shifting to the function call take a while to complete.
The time it takes to jump to the calling function may be longer than the time it takes to run that function if a function is short, as overheads might eat up a large portion of its execution time.
One of the answers to this problem is macro definitions, sometimes known as macros.

In 2023 for C++ language, this issue is tackled in a different way. To cut down on the time it takes to call short functions, C++ adds a new function called the inline function.
This article updated on 2023 will give the reader an overview of inline functions in C++, a crucial area of programming, and then show them in action.

What is Inline function in C++

Similar to how macros in C reduce programme execution time, inline functions are an optimization feature in C++. When managing classes in C++, this idea of inline functions is applied. But it is also applied in other contexts. The compiler substitutes it with a copy of that function's code whenever such a function is found (function definition). To put it another way, one may say that a function like this is enlarged in-line, hence the name inline function.
When a programme calls a function multiple times and the definitions are brief, inline functions are frequently employed. It takes less time to move programme control from the calling function to the definition of the called function when inline functions are used.

To the compiler, inlining a function is only a request or a suggestion—it is not a requirement. The compiler will decide whether to accept or reject this recommendation to inline a certain function. Under some of the following conditions, the compiler is most likely to disregard the inlining of a function:

⮞ The compiler does not comply with the programmer's request to make a function with a return statement that is marked as inline and without returning any value an inline function.

⮞ The compiler rejects the inline recommendation when a programmer tries to inline a function that has a loop (for, while, or do-while).

⮞ Recursive functions are unable to be inlined.

⮞ It is not possible to convert a function with static variables into an inline function.

⮞ If a function requests to be inlined but contains switch or go-to statements, the compiler rejects the request.

Syntax

inline return_type function_name(parameters){
    // function code
}  

Let's take an example

#include <iostream>

using namespace std;

inline int subtract_func(int x, int y) {
  return x - y;
}
inline int add_func(int a, int b) {
  return a + b;
}

// Main function
int main() {
  cout << add_func(1, 11) << endl;
  cout << subtract_func(100, 75) << endl;
  return 0;
}

        Try it Yourself 

What is the issue with macros

Readers who are familiar with the C programming language are aware that it uses macros. All macro calls are directly replaced by the preprocessor in the macro code. It is advised to use inline functions rather than macros whenever possible. Dr. Bjarne Stroustrup, the man behind C++, claims that because macros are error-prone and rarely essential in C++. The use of macros in C++ has significant drawbacks. Private members of a class are inaccessible to macro. Although macros appear to be function calls, they are not.

#include <iostream>
using namespace std;
class func
{
	int x;
public:
#define MAC(func::x) // error
};

The C++ compiler verifies that the necessary conversions are made and that the inline functions' parameter types are valid. A preprocessor macro cannot accomplish this. Additionally, the preprocessor manages macros, while the C++ compiler manages inline functions.
Recall: While it is true that all functions specified inside a class are implicitly inlined and that the C++ compiler will call them inline, inlining cannot be done if the function is virtual. This is due to the fact that calls to virtual functions are resolved at runtime rather than at compile time. If the compiler doesn't know which function will be called, how can it conduct inlining? Virtual implies to delay action until runtime, and inlining means to act immediately after compilation.

If the function is not expanded inline, the compiler may provide a warning, depending on the one you are using. Inline functions are not supported by programming languages like Java and C#.
However, because final methods cannot be altered by subclasses and calls to final methods are resolved at compile time in Java, the compiler can execute inlining when the small final method is called. By inlining short function calls, the JIT compiler in C# can also optimise code (like replacing body of a small function when it is called in a loop).

When to use inline function

As needed, we can use the inline function. Here are a few suggestions that could be helpful:
The inline function can be used when performance is required.
In place of macros, we can utilise the inline function.
To hide function implementation specifics, we prefer to utilise the inline keyword outside of the class with the function definition.

Things to keep in mind when utilising Inline functions

⮞ Small inline functions must be maintained since they perform better and are more effective.

⮞ Although turning all functions into inline functions does boost performance, we shouldn't do so. Because moving huge functions intoline could result in code bloat and a reduction in efficiency.

⮞ It is advised to declare huge functions outside the definition of a class using the scope resolution:: operator because, if defined inside the definition of a class, they may become inlined automatically, which would again reduce the efficiency of our code.

Advantages of Inline function

These are a few of the factors that will motivate you to use this function in your programmes.

⮞ Since there are no overhead calls, the application runs more quickly.

⮞ The overhead of pushing and removing variables from the stack during function calls is avoided by the function.

⮞ A C++ inline function reduces the overhead of the return call.

⮞ Program execution can be sped up by storing the inline function in a header file to save time.

⮞ Utilizing the instruction cache increases the locality of reference. The speed of CPU-bound applications improves as the number of cache lines utilised to hold the code reduces, pushing it to execute faster.

Drawbacks of C++'s inline function

⮞ It will make the executable larger for lengthy code.

⮞ A simple modification in the inline code will require you to recompile everything because the inline function is called at compilation time.

⮞ Excessive C++ inline functions might slow down the speed at which instructions are transferred from the instruction cache to primary memory.

⮞ Program execution can be sped up by storing the inline function in a header file to save time.

⮞ Inline functions might not be included in embedded systems since code size is more significant than speed.

Crack your next tech interview with confidence!

Classes and functions that can be used inline

The class itself can define the inline method as well. In actuality, all of the class's specified functions are implicitly inlined. Therefore, all restrictions that are applicable to inline functions are also applicable here.
If you must explicitly declare an inline function in a class, do it there before using the inline keyword to specify it outside of the class.

Let's see an example

class x
{
public:
	inline int square(int x) {

	}
};

The method mentioned above is thought to be a poor programming method.
The most effective programming approach is to write the function prototype inside the class and declare it as an inline in the function specification.

class x
{
public:
	int square(int x); 
};

inline int X::square(int x) 
{

}

#include <iostream>
using namespace std;
class Math_riddle
{
	int x,y,plus,subtract,mult;
	float divi;
public:
	void getValue();
	void add();
	void sub();
	void mul();
	void div();
};
inline void Math_riddle :: getValue()
{
	cout << "Enter first value:";
	cin >> x;
	cout << "Enter second value:";
	cin >> y;
}

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

inline void Math_riddle :: sub()
{
	subtract = x-y;
	cout << "Difference of two numbers: " << x-y << "\n";
}

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

inline void Math_riddle ::div()
{
	divi=x/y;
	cout<<"div of two numbers: "<<x/y<<"\n" ;
}

int main()
{
	cout << "Program using inline function\n";
	Math_riddle m;
	m.getValue();
	m.add();
	m.sub();
	m.mul();
	m.div();
	return 0;
}

        Try it Yourself 

Important Notes

Here are a few key elements concerning inline functions that should be kept in mind when utilising the C++ language as an overview of the entire issue of inline functions.

⮞ Inline functions are not required; they are merely recommendations. The compiler might not inline the routines that the programmer marked as inline. In addition, even if a function is not designated as inline, the compiler may nevertheless choose to inline it.

⮞ Since they are already considered to be inline functions by default, functions that are declared and defined inside of a class do not need to be explicitly defined as such.

⮞ Inline works as a compiler controlled copy and paste action and is not implemented forcibly, which makes it easier to debug than pre-processor macros and ensures that the namespaces and code are not corrupted.

⮞ Virtual methods cannot be inlined until the compiler is aware of the object's type, which occurs when the object is defined and built within the same function body.

⮞ A method or function is not immediately inlined only because it is used as a template in the header section.

Inline Function Vs Normal Function

Inline Function Vs Macros

FAQs

What distinguishes inline functions in C++ from normal functions and why are they necessary?

The control is often sent from the calling application to the called function during a function call.
Following programme execution, the called function hands back control to the caller programme along with a return value.
Because the function can be called at any desired point in the programme, rather than having to write the same code many times, this concept of function saves programme space.
This could be useful for shrinking the size of the programme, but it definitely lengthens the time it takes to run as the function must be called each time control is passed to it before returning a value.

This is highly helpful for large functions, but for minor functions, a user might want to explicitly insert the function definition code in the called position to speed up execution.
To reduce the overhead of function calls, C++ offers inline functions. In order to eliminate function calls, the compiler creates a copy of the function's code each time it is called.

Conclusions

This concludes our discussion of "Inline Function in C++." I sincerely hope that you learned something from it and that it improved your knowledge. You can consult the C++ Tutorial if you want to learn more about C++.

Good luck and happy learning!