Differences between the inline function and the normal function in C++

The function is a block of reusable code that performs a particular task. It is defined and called for from different sections of the program. In C++, the functions are divided into many types based on their usage and features. These are Regular functions, Inline functions, Recursive functions, Friend functions, Virtual functions, Lambda functions, etc. These functions are essential for organizing and structuring the code and making the entire program maintainable.

Normal function:

Regular or normal functions are the most common functions in C++. They are defined outside of any class and have a separate block of code called when the function is invoked. When the normal function is called, the compiler creates a new stack frame for the functions to track the function calls.

This function has a return type. It will return some value after doing computation. It takes some values whenever it is called. Those values are generally called arguments. The function will work on those arguments and return the output. There will be no return type for some normal functions, which means those have a void return type.

Syntax of the Normal Function:

It has the following syntax:

return_type function_name(parameters) {
 // Function code
 return result; 
}

The return type specifies the type of the value the function returns. Parameters are input to the function, which are always present in parentheses. The function code is written in {}. The return is used to give output to the function, which is called.

Example:

Let us take a C++ program to illustrate the normal functions:

#include <iostream>
using namespace std;
int add(int a, int b) {
 return a + b;
};
int main() {
 int a,b;
 cout << "Enter the values of a and b "<< endl;
 cin >> a >> b;
 int result = add(a,b);
 cout << "Addition of two numbers are " << result << endl;
 return 0;
}

Output:

Inline function:

Inline functions are special types of functions in C++. Which are small, frequently used code snippets. These are directly inserted into the code at the point where they are called are called inline functions. The compiler will replace the function call with the actual code at the call site for performance optimization. So here, the new stack frame is not created for the function or jumps to a separate block of code. It will help to improve the performance.

Syntax of the Inline function:

It has the following syntax:

inline return_type function_name(parameters) {
 // Function code
 return result; 
}

The keyword "inline" is used to use the inline function. The return type is not mandatory. Parameters are input values of the function.

Example:

Let us take a C++ program to illustrate the inline functions:

#include <iostream>
using namespace std;
inline int add(int a, int b) {
 return a + b;
};
int main() {
 int a,b;
 cout << "Enter the values of a and b "<< endl;
 cin >> a >> b;
 int result = add(a,b);
 cout << "Addition of two numbers are " << result << endl;
 return 0;
}

Output:

Similarities between the inline function and normal function:

There are several similarities between the inline and normal functions. Some main similarities between the inline and normal functions are as follows:

Aspect	Inline function	Normal function
Return type	Both can have any valid return type.	Return types can be any valid data type.
Parameters	It can take parameters, including default values.	Parameters can be defined with or without defaults.
Function prototypes	It can be declared with or without function prototypes.	It is typically declared with function prototypes.
Visibility	Both can be declared in various scopes (global, namespace, class).	Visibility depends on the scope and access modifiers.
Modularity	Encourage modularity by encapsulating code.	Promote modularity by encapsulating code in functions.

Differences between the inline functions and normal functions:

There are several differences between the inline and normal functions. Some main differences between the inline and normal functions are as follows:

Aspect	Inline function	Normal function
Inlining	The code is written at the call place for optimization	The function code is called at the function site
Code duplication	It may lead to code duplication at multiple call sites.	Single copy of code shared among all call sites.
Execution speed	Faster because there is overhead for function call.	Slower due to function call setup.
Stack frame	There is no stack frame created.	A new stack frame is created.
Code size	It may be larger due to duplication.	The code will be compact.
Readability	Reading and understanding the inline function is difficult.	It will be cleaner, more readable, and easily understood.
Debugging	Debugging can be more challenging due to scattered code.	Easier debugging with a centralized function code.
Recursive calls	These are not used for recursive calls.	These are more suitable for recursive calls.
Compile time	Results in longer compiler time due to code duplication.	Faster compilation due to single-function definition.
Header files	Often defined in header files to ensure inlining across translation units.	Typically declared in header files but defined in source files.
Function pointers	This function cannot have function explicitly assigned.	It can have pointers pointing to addresses.
Virtual functions	It cannot be virtual because the keyword virtual is not applicable.	It can be declared as virtual to enable polymorphism in classes.