# Immediate Functions in C++

In this article, we will discuss the immediate function used in C++.

__Immediate Function__:

- In C++20, an immediate function is a function where every call to the function either directly or indirectly produces a compile-time constant expression.
- These functions are declared by using a
**consteval**keyword before their return type.

Below given some important terms related to Immediate Function:

__constexpr function__:

__constexpr function__:

- The
**constexpr**specifier declares that it is possible to evaluate the value of a function or variable at compile time. - Such variables and functions can then be used where only compile-time constant expressions are allowed.
- These functions are used to improve the performance of the program by doing computations at compile time instead of run time.
- These functions can really be helpful, where executing a program multiple times as the constant expressions will only be evaluated once during the compile time.

Below is the C++ program illustrating the use of constexpr function:

## C++14

`// C++ program demonstrates the use of` `// constexpr` `#include <iostream>` `using` `namespace` `std;` ` ` `// Constexpr function if replaced with` `// consteval, program works fine` `constexpr ` `int` `fib(` `int` `n)` `{` ` ` `// Base Case` ` ` `if` `(n <= 1)` ` ` `return` `n;` ` ` ` ` `// Find the Fibonacci Number` ` ` `return` `fib(n - 1) + fib(n - 2);` `}` ` ` `// Driver Code` `int` `main()` `{` ` ` `// Constant expression evaluated` ` ` `// at compile time` ` ` `const` `int` `val = fib(22);` ` ` ` ` `cout << ` `"The fibonacci number "` ` ` `<< ` `"is: "` `<< val << ` `"\n"` `;` ` ` ` ` `return` `0;` `}` |

**Output**

The fibonacci number is: 17711

**Explanation:**

- In the above example,
**fib()**is called with**22**. - That’s why, it is a constant expression and so, it can be evaluated at compile time.
- The program shows no error either at using
**constexpr**or**consteval**. - But, if the constant expression is used while using the consteval keyword, the program will produce an error.

__consteval function__:

__consteval function__:

- In
**consteval**function, every call to the function must directly or indirectly produce a compile-time constant expression. - The consteval function is the same as constexpr function except that if the call to a consteval function doesn’t evaluate to a compile-time constant expression, then the program gives an error while it is not so in the case of a
**constexpr**function. - The
**constexpr**specifies that the value of a variable or function can appear in constant expressions. - The key to note here is that it says, a function can appear in constant expressions, it doesn’t say that the function has to be, while a
**consteval**specifies that a function is an immediate function, that is, every call to the function must produce a compile-time constant.

Below is the C++ program illustrating the use of consteval function:

## C++14

`// C++ program illustrating the use` `// of the consteval function` ` ` `#include <iostream>` `using` `namespace` `std;` ` ` `// If constexpr replaces with consteval` `// program gives an error in C++20` `constexpr ` `int` `fib(` `int` `n)` `{` ` ` `// Base Case` ` ` `if` `(n <= 1)` ` ` `return` `n;` ` ` ` ` `return` `fib(n - 1) + fib(n - 2);` `}` ` ` `// Driver Code` `int` `main()` `{` ` ` `// This expression is not evaluated` ` ` `// at compile time` ` ` `const` `int` `val = fib(` `rand` `() % 20);` ` ` ` ` `cout << ` `"The fibonacci number is: "` ` ` `<< val << ` `"\n"` `;` ` ` ` ` `return` `0;` `}` |

**Output**

The fibonacci number is: 2

**Explanation:**

- In the above example,
**rand()**is used and**rand()**gets evaluated at runtime not at compile time and so because of that, the expression is no longer a constant expression, that’s why our**consteval**function will now produce an error. - While the
**constexpr function**still works fine and the reason is that it doesn’t have to be at compile time.

**Conclusion:**

- From the above discussion, it can be concluded that the Immediate function is
**consteval function**, which works fine only when every call to the function must directly or indirectly produce a compile-time constant expression otherwise gives an error. - These functions are declared by using a consteval keyword before their return type and are used to reduce the time, consumed in evaluating the constant expressions as they evaluate the constant expressions only once during the compile-time and not during every run/execution of the program.
- Hence, it saves a considerable amount of time when there is a need to execute a program with some constant expressions multiple times.

Want to learn from the best curated videos and practice problems, check out the

**C++ Foundation Course**for Basic to Advanced C++ and**C++ STL Course**for foundation plus STL. To complete your preparation from learning a language to DS Algo and many more, please refer**Complete Interview Preparation Course****.**