If we desire to define a function before calling the strategy, utilize its function declaration or prototype which informs the compiler that we will use the function with the name stated in the prototype at a certain juncture in the programming language. As a consequence of this, the assembler can convey some more consistent leading choices. The descriptor configuration is done initially in a function prototype, followed by the keyword function, then the function name. You can pluck the function header from each of your function definitions by adding a semicolon (;) and placing the prototypes in a header. Then, include that header at the beginning of each processing unit in your program.
In this article, we will discuss a declaration of a function named “prototype function” which tells us to be concerned with the type of value returned by the function and arguments along with their types. One immensely helpful dimension of C++ functions is the prototyping function. A function prototype presents insight that includes the number and nature of parameters and the type of return values to characterize the functional interface to the assembler.
A semicolon must abide by the function prototype at the final point. The tool we that we use to discuss the “function prototype” is “Visual Studio Code”. It minimizes the return-type error for the data that the function emits. It reflects how the several factors were delivered to the function, and indicates the data types including each passed input. If there is some flaw in the code, we fix a prototype bug by putting the entirety of your user-defined function before the core functions, then establishing a function prototype before maiming after the CPP headers.
The code ownership is handed to the function definition when the compiler commences a function call. When the return statement or closing braces() are approached, the compiler then executes the instructions within the function’s body and programmed control, then returns.
Example 1: Describing the Addition of Two Simple Functions with the Return Statement
Let’s discuss our first example to implement the prototype. We will discuss how we can simply add two of our functions to the prototype. The function descriptor code should reside well before the function call in the Cpp. However, we must employ the function prototype if we want to specify a function after the function call. For this purpose, we need to do our function declaration first using “int add(int m, int n)”. By the declaration of “add”, the compiler understands twice the arguments with “int” and “return” types.
After that, we declare our three variables for the sake of passing the values to control the definition of add-on “int m” and “int n”. Here, we can say that “q” and “r” are actual parameters. We declare the variable as “g”. The variables “q” and “r” are integer data types that store the values of “05” and “31”. The variable “g” has the variable “q” and “r” along with the “add” function.
To display something on the output screen, we use the “cout” command in CPP. So, we print the “Addition Value” along with the value that is stored in the variable “g”. Apply the prototype function. It declares again the integer data type name “add” and store the variables “m” and “n”. We store the sum of variables “m” and “n” on our newly integer data type declared variable “k”. Simply return the variable “k” using the “return” statement and return to the main program value received by “g”. This whole respective code explains the prototype function by adding two simple functions.
The output simply displays the sum of “5” and “31” that are stored in variables “q” and “r” along with the “cout” statement in which we assigned to print as “Addition Value” which is “36”. It can be seen on the output display.
Example 2: Describing the Prototype Function with Two Parameters
To discuss the prototype function in a good manner, we now take the example as having two parameters. First, the simple header file of “iostream” is used for CPP implementation. In simplest terms, the formal parameters and actual parameters serve as the only two parameters that can be engaged. The formal parameters are the variables that are proclaimed in the function. The actual parameters are the values that are sourced to the function. When invoking a function, the nature of the explanations made must match the type of the corresponding parameters indicated in the function declaration.
We declare our user-defined void function as “DisplayNumber” to store with two parameters in it which are “val1” and “val2”. The use of the user-defined functions makes the code reusable, consolidates the program, and enhances readability. Our parameter “val1” is an integer data type while “val2” is a float data type as it has the capacity of storing the decimal place values. After that, we use two “cout” statements along with the display message of “The Parameter int Number is” and assign it with the parameter of the integer data type “val1”. For the float parameter, we also use a “cout” statement along with its message and assign the parameter of “val2”.
Now, if we look at our main function here, we declare the value of integer and float data types for both parameters as “5” and “5.5”. Then, we call our “DisplayNumber()” function with the assassination of both parameters “val1” and “val2” and return the main function using the “return” statement.
The output simply displays the data values of both parameters of “val1” and “val2” stored values which are “5” and “5.5” along with the “cout” display message.
In our article, we discussed the usage of the prototype function with the help of two solid examples. In our first example, we got know how we can simply add two values or variables using the return value. In our second example, we learned how we can elaborate the prototype function that contains multiple parameters.