(i) A local variable is defined within a block. A block of code begins and ends with curly braces { }.
(ii) The scope of a local variable is the block in which it is defined.
(iii) A local variable cannot be accessed from outside the block of its declaration.
(iv) A local variable is created upon entry into its block and destroyed upon exit

Arguments or parameters are the means to pass values from the calling function to the called function. The variables used in the function definition as parameters are known as formal parameters. The constants, variables or expressions used in the function call are known as actual parameters.
Types : Default arguments and Constant Arguments.

Void type has two important purposes:
(I) To indicate the function does not return a value
(ii) To declare a generic pointer

In C++, one can assign default values to the formal parameters of a function prototype. The Default arguments allows to omit some arguments when calling the function.
When calling a function,
For any missing arguments, complier uses the values in default arguments for the called function.
i. The default value is given in the form of variable initialization.
Example: void defaultvalue(int n1-10. n2=100);
ii. The default arguments facilitate the function call statement with partial or no arguments.
Example: defaultvalue(x,y);
defaultvalue(200,150);
defaultvalue(150);
defaultvalue(x,150);
iii. The default values can be included in the function prototype from right to left, ie, we cannot have a default value for an argument in between the argument list.
Example: void defaultvalue(int n1-10, n2);//invalid prototype
void defaultvalue(int n1, n2 = 10);//valid prototype

(i) The return value of the function is of type long.
(ii) fact is the name of the function.
(iii) The function is called with two arguments:
The first argument is of int data type.
The second argument is of double data type. 
int display(int, int) // function prototype
The above function prototype provides details about the return data type, name of the function and a list of formal parameters or arguments.

The pow() function returns base raised to the power of exponent. If any argument passed to pow() is long double, the return type is promoted to long double. If not, the return type is double. The pow() function takes two arguments.
(i) base- the base value
(ii) exponent - exponent of the base
Example :
cout <<pow(5,2);
output
25

#include<iostream>
using namespace std;
int reverse (int n);
int main()
{
int n=0, result = 0;
cout<<"Enter number:"";
cin >>n;
result reverse (n);
cout<<"Reverse number is:" << result << endl;
}
int reverse (int n)
{
int temp=0, rev = 0;
while (n! =0).
{
temp=n;
rev= (rev*10) + temp;
n = n/10;
}
return rev;
}
Output:
Enter number: 1 2 3
Reverse number: 3 2 1

This method copies the value of an actual parameter into the formal parameter of the function. In this case, changes made to formal parameter within the function will have no effect on the actual parameter.
Example :
#include < iostream >
using namespace std;
void display(int x)
{
int a=x*x;
cout << "\n\nThe Value inside display function (a*a):"<< a;
}
int maint()
{
int a;
cout << "\nExample : Function call by value:";
cout << "\n\nEnter the Value for A:";
cin >> a;
display(a);
cout << "\n \nThe Value inside main function" << a;
return(0);
}
Output:
Example: Function call by value
Enter the Value for A:5
The Value inside display function (a * a) : 25
The Value inside main function 5