Chapter five

Function
A function is a group of statements that together perform a task and often returns a value. A
program written with numerous functions is easier to maintain, update and debug than one very
long program. Functions allow to structure programs in segments of code to perform individual
tasks. Each function has its own name. When that name is encountered in a program, the
execution of the program branches to the body of that function. When the function is finished,
execution returns to the area of the program code from which it was called, and the program
continues on to the next line of code. Every C++ program has at least one function, which is
main(), and all the most trivial programs can define additional functions. Functions are often
called modules.
Advantages of Functions

The advantages of writing functions are

 Functions provides reusability
 Functions give modular structure to a program
 Writing functions make programming easy
In C++, the concept of a function, either predefined or user-defined, is similar to that of a
function in algebra.
5.1. Predefined function
In algebra, a function can be considered a rule or correspondence between values, called the
function’s arguments, and the unique values of the function associated with the arguments. Thus,
if f(x) = 2x + 5, then f(1) = 7, f(2) = 9, and f(3) = 11, where 1, 2, and 3 are the arguments of f,
and 7, 9, and 11 are the corresponding values of the function f.
Some of the predefined mathematical functions are pow(x, y), sqrt(x), and floor(x).
 The power function, pow(x, y), calculates xy; that is, the value of pow(x, y)= xy.
 The square root function, sqrt(x), calculates the nonnegative square root.
 The floor function, floor(x), calculates the largest whole number that is less than or
equal to x.
In C++, predefined functions are organized into separate libraries. For example, the header file
iostream contains I/O functions, and the header file math contains math functions.
To use predefined functions in a program, you must include the header file that contains the
function’s specification.
#include <iostream>
#include <math>
#include <ctype>
using namespace std;
int main()
{
int x;
double u, v;
cout << "Line 1: Uppercase a is "
<< static_cast<char>(toupper('a'))
<< endl; //Line 1
u = 4.2; //Line 2
v = 3.0; //Line 3
cout << "Line 4: " << u << " to the power of "<< v << " = " << pow(u, v) << endl; //Line 4
cout << "Line 5: 5.0 to the power of 4 = "<< pow(5.0, 4) << endl; //Line 5
u = u + pow(3.0, 3); //Line 6
cout << "Line 7: u = " << u << endl; //Line 7
x = -15; //Line 8
cout << "Line 9: Absolute value of " << x<< " = " << abs(x) << endl; //Line 9
return 0;
}

5.2. User-Defined Functions

In C++, a function is a group of statements that is given a name, and which can be called from
some point of the program.
User-defined functions in C++ are classified into two categories:
 Value-returning functions—functions that have a return type. These functions return a
value of a specific data type using the return statement, which we will explain shortly.
 Void functions—functions that do not have a return type. These functions do not use a
return statement to return a value.
5.2.1 Value-returning functions
Predefined C++ functions such as pow, abs, islower, and toupper. These are examples of value-
returning functions. To use these functions in your programs, you must know the name of the
header file that contains the functions’ specification. Value-returning functions includes
1. The name of the function
2. The number of parameters, if any
3. The data type of each parameter
4. The data type of the value computed (that is, the value returned) by the function, called the type of the
function
5. The code required to accomplish the task
6. body
The first fifth properties form what is called the heading of the function (also called the function
header); the sixth property is called the body of the function. Together, these five properties
form what is called the definition of the function. For example, for the function abs, the heading
might look like:
int abs(int number)
{
if (number < 0)
number = -number;
return number;
}
The variable declared in the heading of the function abs is called the formal parameter of the
function abs. Thus, the formal parameter of abs is number.
double pow(double base, double exponent) // heading of the function pow and formal parameters
double m = 2.5; // of pow is base and exponent
double n = 3.0;
double x, y;
x = pow(m, n); //Line 1
y = pow(2.0, 3.2) + 5.1; //Line 2
cout << m << " to the power of 7 = " << pow(m, 7) << endl; //Line 3

The values of m and n are passed to the function pow. In fact, the value of u is copied into base,
and the value of v is copied into exponent. The variables m and n that appear in the call to the
function pow in Line 1 are called the actual parameters of that call. In Line 2, the function pow is
called with the parameters 2.0 and 3.2. In this call, the value 2.0 is copied into base, and 3.2 is
copied into exponent. Moreover, in this call of the function pow, the actual parameters are 2.0
and 3.2, respectively. Similarly, in Line 3, the actual parameters of the function pow are m and 7;
the value of m is copied into base, and 7.0 is copied into exponent.
Formal Parameter: A variable declared in the function heading.
Actual Parameter: A variable or expression listed in a call to a function.
Syntax: Value-Returning function

 Function Name: T his is the actual name of the function. The function name and the
parameter list together constitute the function signature.
 FunctionType is the type of the value that the function returns. The functionType is also
called the data type or the return type of the value-returning function.
 Statements enclosed between curly braces form the body of the function that specify what
the function actually does. In which statements are usually declaration statements and/or
executable statements.
 Function Body: The function body contains a collection of statements that define what the
function does.
Syntax: Formal Parameter List
The syntax of the formal parameter list is:

 Parameters List (as many as needed): Each parameter consists of a type followed by an
identifier, with each parameter being separated from the next by a comma. Each parameter
looks very much like a regular variable declaration (for example: int x), and in fact acts
within the function as a regular variable which is local to the function.
 The purpose of parameters is to allow passing arguments to the function from the location
where it is called from.
Function Call
The syntax to call a value-returning function is:

Syntax: Actual Parameter List

The syntax of the actual parameter list is:

 Expression can be a single constant value. To call a value returning function, you use its
name, with the actual parameters (if any) in parentheses.
 A function’s formal parameter list can be empty. However, if the formal parameter list is
empty, the parentheses are still needed.
 If the formal parameter list is empty, the following form:

 If the formal parameter list of a value-returning function is empty, the actual parameter is
also empty in a function call. In this case (that is, an empty formal parameter list), in a
function call, the empty parentheses are still needed.
 Thus, a call to a value-returning function with an empty formal parameter list is:
 In a function call, the number of actual parameters, together with their data types, must match
with the formal parameters in the order given.
 Actual and formal parameters have a one-to-one correspondence.
A value-returning function is called is an expression. The expression can be part of either an
assignment statement or an output statement, or a parameter in a function call.
A function call in a program causes the body of the called function to execute.
return Statement
Once a value-returning function computes the value, the function returns this value via the return
statement. In other words, it passes this value outside the function via the return statement.
Syntax: return Statement
The return statement has the following syntax:

 In which expr is a variable, constant value, or expression. The expr is evaluated, and its value
is returned.
 The data type of the value that expr computes must match the function type.
In C++, return is a reserved word. When a return statement executes in a function, the function
immediately terminates and the control goes back to the caller. Moreover, the function call
statement is replaced by the value returned by the return statement. When a return statement
executes in the function main, the program terminates.

Look at the following examples. Let us write a function that determines the larger of two
numbers. Because the function compares two numbers, it follows that this function has two
parameters and that both parameters are numbers.

double larger(double x, double y)

{
double max;
if (x >= y)
max = x;
else
max = y;
return max;
}
 variable max (called a local declaration, in which max is a variable local to the
function larger).

This program is divided in two functions: addition and main. Remember that no matter the order
in which they are defined, a C++ program always starts by calling main. In fact, main is the only
function called automatically, and the code in any other function is only executed if its function
is called from main (directly or indirectly).In the example above, main begins by declaring the
variable z of type int, and right after that, it performs the first function call: it calls addition. The
call to a function follows a structure very

similar to its declaration. In the example above, the call to addition can be compared to its
definition just a few lines earlier:
The parameters in the function declaration have a clear correspondence to the arguments passed
in the function call. The call passes two values, 5 and 3, to the function; these correspond to the
parameters a and b, declared for function addition.

At the point at which the function is called from within main, the control is passed to function
addition: here, execution of main is stopped, and will only resume once the addition function
ends. At the moment of the function call, the value of both arguments (5 and 3) are copied to the
local variables int a and int b within the function.
Then, inside addition, another local variable is declared (int r), and by means of the expression
r=a + b, the result of a plus b is assigned to r; which, for this case, where a is 5 and b is 3, means
that 8 is assigned to r.
The final statement within the function: return r; 
Ends function addition, and returns the control back to the point where the function was called;
in this case: to function main. At this precise moment, the program resumes its course on main
returning exactly at the same point at which it was interrupted by the call to addition. But
additionally, because addition has a return type, the call is evaluated as having a value, and this
value is the value specified in the return statement that ended addition: in this particular case, the
value of the local variable r, which at the moment of the return statement had a value of 8.

Therefore, the call to addition is an expression with the value returned by the function, and in
this case, that value, 8, is assigned to z. It is as if the entire function call (addition(5,3)) was
replaced by the value it returns (i.e., 8).
Then main simply prints this value by calling:
cout << "The result is " << z;
A function can actually be called multiple times within a program, and its argument is naturally
not limited just to literals:
// function example
#include <iostream>
using namespace std;
int subtraction (int a, int b)
{
int r;
r=a-b;
return r; The first result is 5
}
The second result is 5
int main ()
{ The third result is 2
int x=5, y=3, z; The fourth result is 6
z = subtraction (7,2);
cout << "The first result is " << z << '\n';
cout << "The second result is " << subtraction (7,2) << '\n';
cout << "The third result is " << subtraction (x,y) << '\n';
z= 4 + subtraction (x,y);
cout << "The fourth result is " << z << '\n';
}
Similar to the addition function in the previous example, this example defines a subtract
function, that simply returns the difference between its two parameters. This time, main calls this
function several times, demonstrating more possible ways in which a function can be called.
Let's examine each of these calls, bearing in mind that each function call is itself an expression
that is evaluated as the value it returns. Again, you can think of it as if the function call was itself
replaced by the returned value:
z = subtraction (7,2);
cout << "The first result is " << z;

If we replace the function call by the value it returns (i.e., 5), we would have:
z = 5;
cout << "The first result is " << z;

With the same procedure, we could interpret:

cout << "The second result is " << subtraction (7,2);

as:
cout << "The second result is " << 5;

since 5 is the value returned by subtraction (7,2).

In the case of:

cout << "The third result is " << subtraction (x,y);
The arguments passed to subtraction are variables instead of literals. That is also valid, and
works fine. The function is called with the values x and y have at the moment of the call: 5 and 3
respectively, returning 2 as result.

The fourth call is again similar:

z = 4 + subtraction (x,y);
The only addition being that now the function call is also an operand of an addition operation.
Again, the result is the same as if the function call was replaced by its result: 6. Note, that thanks
to the commutative property of additions, the above can also be written as:
z = subtraction (x,y) + 4;
With exactly the same result. Note also that the semicolon does not necessarily go after the
function call, but, as always, at the end of the whole statement. Again, the logic behind may be
easily seen again by replacing the function calls by their returned value:
1 z = 4 + 2; // same as z = 4 + substraction (x,y);
2 z = 2 + 4; // same as z = substraction (x,y) + 4;
5.2.2 Functions with no type. The use of void
The syntax shown above for functions:

type name ( argument1, argument2 ...)

{
 statements ;
}
Requires the declaration to begin with a type. This is the type of the value returned by the
function. But what if the function does not need to return a value? In this case, the type to be
used is void, which is a special type to represent the absence of value. For example, a function
that simply prints a message may not need to return any value:
// Example 19: void function example
#include <iostream>
using namespace std;
void printmessage ()
{
cout << "I'm a function!"; I'm a function!
}
int main ()
{
printmessage ();
}
void can also be used in the function's parameter list to explicitly specify that the function takes
no actual parameters when called. For example, printmessage could have been declared as:
void printmessage (void)
{
cout << "I'm a function!";
}
In C++, an empty parameter list can be used instead of void with same meaning, but the use of
void in the argument list was popularized by the C language, where this is a requirement.
Something that in no case is optional are the parentheses that follow the function name, neither
in its declaration nor when calling it. And even when the function takes no parameters, at least an
empty pair of parentheses shall always be appended to the function name. See how printmessage
was called in an earlier example:
printmessage ();

The parentheses are what differentiate functions from other kinds of declarations or statements.
The following would not call the function:
printmessage;

5.3 Function Prototypes

Typical definition or prototype for a function contains
 The type of the value it returns
 An identifier for its name and
 The list of parameters with their types.
The syntax to write a proto type is:
<return type> function name(Parameter list);
Note that the function prototype ends with a semicolon.
For the function larger, the prototype is:
double larger(double x, double y);
When writing the function prototype, you do not have to specify the variable name in the
parameter list. However, you must specify the data type of each parameter.
You can rewrite the function prototype of the function larger as follows:
double larger(double, double);
The program given below is a makes use of a simple function that takes a integer parameter.
Example
#include <iostream>
using namespace std;
void show(int); // FUNCTION PROTOTYPE
void main()
{
int a;
cout<<”Enter the value for A”;
cin>>a
show(a);
}
void show(int x)
{
cout<<”The value passed to function is “<< x;
}
Example
This function show() used in this program takes two parameters and returns the sum of the
parameters
#include <iostream>
using namespace std;
int mul(int,int); // FUNCTION PROTOTYPE
void main()
{
int a,b,c;
cout<<”Enter two values <<endl”;
cin>>a>>b;
c=mul(a,b);
cout<<”The Product is “<<c;
}
int show(int x,int y)
{
int z;
z=x * y;
return z;
}
Let's have a look at an example:
// function example The result is 8
#include <iostream>
using namespace std;
int addition (int a, int b)
{
int r;
r=a+b;
return r;
}
int main ()
{
int z;
z = addition (5,3);
cout << "The result is " << z;
}
The return value of main
You may have noticed that the return type of main is int, but most examples in this and earlier
chapters did not actually return any value from main.
Well, there is a catch: If the execution of main ends normally without encountering a return
statement the compiler assumes the function ends with an implicit return statement:
return 0;
Note that this only applies to function main for historical reasons. All other functions with a
return type shall end with a proper return statement that includes a return value, even if this is
never used.
When main returns zero (either implicitly or explicitly), it is interpreted by the environment as
that the program ended successfully. Other values may be returned by main, and some
environments give access to that value to the caller in some way, although this behavior is not
required nor necessarily portable between platforms.
The values for main that are guaranteed to be interpreted in the same way on all platforms are:
value description
0 The program was successful
The program was successful (same as above).
EXIT_SUCCESS
This value is defined in header <cstdlib>.
The program failed.
EXIT_FAILURE
This value is defined in header <cstdlib>.

Because the implicit return 0; statement for main is a tricky exception, some authors consider it
good practice to explicitly write the statement.
Arguments passed by value and by reference
In the functions seen earlier, arguments have always been passed by value. This means that,
when calling a function, what is passed to the function are the values of these arguments on the
moment of the call, which are copied into the variables represented by the function parameters.
For example, take:
int x=5, y=3, z;
z = addition ( x, y );

In this case, function addition is passed 5 and 3, which are copies of the values of x and y,
respectively. These values (5 and 3) are used to initialize the variables set as parameters in the
function's definition, but any modification of these variables within the function has no effect on
the values of the variables x and y outside it, because x and y were themselves not passed to the
function on the call, but only copies of their values at that moment.

In certain cases, though, it may be useful to access an external variable from within a function.
To do that, arguments can be passed by reference, instead of by value. For example, the function
duplicate in this code duplicates the value of its three arguments, causing the variables used as
arguments to actually be modified by the call:
// Example 20: passing parameters by reference
#include <iostream>
using namespace std;
void duplicate (int& a, int& b, int& c)
{
a*=2;
b*=2;
c*=2;
x=2, y=6, z=14
}
int main ()
{
int x=1, y=3, z=7;
duplicate (x, y, z);
cout << "x=" << x << ", y=" << y << ", z=" << z;
return 0;
}
To gain access to its arguments, the function declares its parameters as references. In C++,
references are indicated with an ampersand (&) following the parameter type, as in the
parameters taken by duplicate in the example above.
When a variable is passed by reference, what is passed is no longer a copy, but the variable itself,
the variable identified by the function parameter, becomes somehow associated with the
argument passed to the function, and any modification on their corresponding local variables
within the function are reflected in the variables passed as arguments in the call.
In fact, a, b, and c become aliases of the arguments passed on the function call (x, y, and z) and
any change on a within the function is actually modifying variable x outside the function. Any
change on b modifies y, and any change on c modifies z. That is why when, in the example,
function duplicate modifies the values of variables a, b, and c, the values of x, y, and z are
affected.

If instead of defining duplicate as:

void duplicate (int& a, int& b, int& c)
Was it to be defined without the ampersand signs as:
void duplicate (int a, int b, int c)
The variables would not be passed by reference, but by value, creating instead copies of their
values. In this case, the output of the program would have been the values of x, y, and z without
being modified (i.e., 1, 3, and 7).
1. Default values in parameters
In C++, functions can also have optional parameters, for which no arguments are required in the
call, in such a way that, for example, a function with three parameters may be called with only
two. For this, the function shall include a default value for its last parameter, which is used by
the function when called with fewer arguments. For example:
// Example 21: default values in functions
#include <iostream>
using namespace std;
int divide (int a, int b=2)
{
int r;
r=a/b;
6
return (r);
5
}
int main ()
{
cout << divide (12) << '\n';
cout << divide (20,4) << '\n';
return 0;
}

In this example, there are two calls to function divide. In the first one:
divide (12)
The call only passes one argument to the function, even though the function has two parameters.
In this case, the function assumes the second parameter to be 2 (notice the function definition,
which declares its second parameter as int b=2). Therefore, the result is 6.
In the second call:
divide (20,4)
The call passes two arguments to the function. Therefore, the default value for b (int b=2) is
ignored, and b takes the value passed as argument, that is 4, yielding a result of 5.
2. Declaring functions
In C++, identifiers can only be used in expressions once they have been declared. For example,
some variable x cannot be used before being declared with a statement, such as:
int x;
The same applies to functions. Functions cannot be called before they are declared. That is why,
in all the previous examples of functions, the functions were always defined before the main
function, which is the function from where the other functions were called. If main were defined
before the other functions, this would break the rule that functions shall be declared before being
used, and thus would not compile.
The prototype of a function can be declared without actually defining the function completely,
giving just enough details to allow the types involved in a function call to be known. Naturally,
the function shall be defined somewhere else, like later in the code. But at least, once declared
like this, it can already be called.
The declaration shall include all types involved (the return type and the type of its arguments),
using the same syntax as used in the definition of the function, but replacing the body of the
function (the block of statements) with an ending semicolon.
The parameter list does not need to include the parameter names, but only their types. Parameter
names can nevertheless be specified, but they are optional, and do not need to necessarily match
those in the function definition. For example, a function called protofunction with two int
parameters can be declared with either of these statements:
int protofunction (int first, int second);
int protofunction (int, int);
Anyway, including a name for each parameter always improves legibility of the declaration.

// Example 22: declaring functions prototypes

#include <iostream.h>
void odd (int x);
void even (int x);
int main()
{
int i;
do {
cout << "Please, enter number (0 to exit): ";
cin >> i; Please, enter number (0 to exit): 9
 odd (i);
} while (i!=0);
return 0;
}
It is odd.
void odd (int x)
Please, enter number (0 to exit): 6
{
It is even.
if ((x%2)!=0) cout << "It is odd.\n";
Please, enter number (0 to exit): 1030
else even (x);
It is even.
}
Please, enter number (0 to exit): 0
void even (int x)
It is even.
{
if ((x%2)==0) cout << "It is even.\n";
else odd (x);
}

This example is indeed not an example of efficiency. You can probably write yourself a version
of this program with half the lines of code. Anyway, this example illustrates how functions can
be declared before its definition:
The following lines:
void odd (int a);
void even (int a);

Declare the prototype of the functions. They already contain all what is necessary to call them,
their name, the types of their argument, and their return type (void in this case). With these
prototype declarations in place, they can be called before they are entirely defined, allowing for
example, to place the function from where they are called (main) before the actual definition of
these functions.
But declaring functions before being defined is not only useful to reorganize the order of
functions within the code. In some cases, such as in this particular case, at least one of the
declarations is required, because odd and even are mutually called; there is a call to even in odd
and a call to odd in even. And, therefore, there is no way to structure the code so that odd is
defined before even, and even before odd.
3. Recursivity
Recursivity is the property that functions have to be called by themselves. It is useful for some
tasks, such as sorting elements, or calculating the factorial of numbers. For example, in order to
obtain the factorial of a number (n!) the mathematical formula would be:
n! = n * (n-1) * (n-2) * (n-3) ... * 1
More concretely, 5! (factorial of 5) would be:
5! = 5 * 4 * 3 * 2 * 1 = 120
And a recursive function to calculate this in C++ could be:
 // Example 23: factorial calculator
#include <iostream.h>
long factorial (long a)
{
if (a > 1)
return (a * factorial (a-1));
else
return 1; 9! = 362880
}
int main ()
{
long number = 9;
cout << number << "! = " << factorial (number);
return 0;
}
Notice how in function factorial we included a call to itself, but only if the argument passed was
greater than 1, since, otherwise, the function would perform an infinite recursive loop, in which
once it arrived to 0, it would continue multiplying by all the negative numbers (probably
provoking a stack overflow at some point during runtime).