The lines that compose a function within a C++ program are called a function definition. The syntax for defining a function is

data_type name_of_function (parameters){

statements;

}

A function definition consists of four parts:

- A reserved word indicating the return data type of the function’s return value.

- The function name

- Any parameters required by the function, contained within parentheses.

- The function’s statements enclosed in curly braces { }.

Example: The following function determines the largest integer among three parameters passed to it.

int maximum( int x, int y, int z )

{

int max = x;

if ( y > max )

max = y;

if ( z > max )

max = z;

return max;

}

You designate a data type for function since it is common to return a value from a function after it executes.

General format of a function is described below.

Variable names that will be used in the function header line are called formal parameters.

To execute a function, you must invoke, or call, it from the main() function.

The values or variables that you place within the parentheses of a function call statement are called arguments or actual parameters.

Example: Function maximum is invoked or called in main() with the call

maximum(a, b, c)

One of the most important features of C++ is the function prototype. A function prototype declares to the compiler that you intend to use a function later in the program. It informs the compiler the name of the function, the type of data returned by the function, the number of parameters the function expects to receive, the types of the parameters and the order in which these parameters are expected. The compiler uses function prototypes to validate function calls.

If you try to call a function at any point in the program prior to its function prototype or function definition, you will receive an error when you compile the project.

If a variable is one of the actual parameters in a function call, the called function receives a copy of the values stored in the variable. After the values are passed to the called function, control is transferred to the called function.

Example: The expression maximum( a, b, c) calls the function maximum() and causes the values currently residing in the variables a, b and c to be passed to maximum().

The method of passing values to a called function is called pass by value.

Functions may have empty parameter list. The function prototype for such a function requires either the keyword void or nothing at all between the parentheses following the function name.

Example:

int display();

int display(void);

For small functions, you can use the inline keyword to request that the compiler replace calls to a function with the function definition wherever the function is called in a program.

C++ enables several functions of the same name to be defined, as long as these functions have different sets of parameters (at least their types are different). This capability is called function overloading.

When an overloaded function is called, the C++ compiler selects the proper functions by examining the number, types and order of the arguments in the call.

Function overloading is commonly used to create several functions of the same name that perform similar tasks but on different data types.

Example:

void showabs(int x)

{

if( x < 0)

x = -x;

cout << “The absolute value of the integer is “ << x << endl;

}

void showabs(double x)

{

if( x < 0)

x = -x;

cout << “The absolute value of the double is “ << x << endl;

}

The function call

showabs(10);

causes the compiler to use the first version of the function showabs.

The function call

showabs(6.28);

causes the compiler to use the second version of the function showabs.

C++ allows default arguments in a function call. Default argument values are listed in the function prototype and are automatically transmitted to the called function when the corresponding arguments are omitted from the function call.

Example: The function prototype

void example (int, int = 5, float = 6.78);

provides default values for the two last arguments.

If any of these arguments are omitted when the function is actually called, the C++ compiler supplies these default values.

Thus, all following function calls are valid:

example(7, 2, 9.3); // no default used

example(7, 2); // same as example(7, 2, 6.78)

example(7); // same as example(7, 5, 6.78)

#include <iostream.h>

int x; // create a global variable named firstnum

void valfun(); // function prototype (declaration)

int main()

{

int y; // create a local variable named secnum

x = 10; // store a value into the global variable

y = 20; // store a value into the local variable

cout << "From main(): x = " << x << endl;

cout << "From main(): y = " << y << endl;

valfun(); // call the function valfun

cout << "\nFrom main() again: x = " << x << endl;

cout << "From main() again: y = " << y << endl;

return 0;

}

void valfun() // no values are passed to this function

{

int y; // create a second local variable named y

y = 30; // this only affects this local variable's value

cout << "\nFrom valfun(): x = " << x << endl;

cout << "\nFrom valfun(): y = " << y << endl;

x = 40; // this changes x for both functions

return;

}

The output of the above program:

From main(): x = 10

From main(): y = 20

From valfun(): x = 10

From valfun(): y = 30

From main() again: x = 40

From main() again: y = 20

In the above program, the variable x is a global variable because its storage is created by a definition statement located outside a function. Both functions, main() and valfun() can use this global variable with no further declaration needed. The program also contains two separate local variables, both named y. Each of the variables named y is local to the function in which their storage is created, and each of these variables can only be used within the appropriate functions.

When a local variable has the same name as a global variable, all uses of the variable’s name within the scope of the local variable refer to the local variable.

In such cases, we can still access to the global variable by using scope resolution operator (::) immediately before the variable name.

The :: operator tells the compiler to use the global variable.

#include <iostream.h>

float number = 42.8; // a global variable named number

int main()

{

float number = 26.4; // a local variable named number

cout << "The value of number is " << ::number << endl;

return 0;

}

The output of the above program:

The value of number is 42.8

Local variables can only be members of the auto, static, or register storage classes.

If no class description is included in the declaration statement, the variable is automatically assigned to the auto class.

Global variables are created by definition statements external to a function. Once a global variable is created, it exists until the program in which it is declared is finished executing.

Global variables may be declared as static or extern (but not both).

The purpose of the extern storage class is to extend the scope of a global variable beyond its normal boundaries. To understand this, we must notice that the programs we have written so far have always been contained together in one file. Thus, when you have saved or retrieved programs, you have only needed to give the computer a single name for your program. Larger programs typically consist of many functions stored in multiple files and all of these files are compiled separately. Consider the following exaple.

Example:

//file1

int a;

float c;

static double d;

.

.

int main()

{

func1();

func2();

func3();

func4();

.

}

int func1();

{

.

.

}

int func2();

{

.

.

}

//end of file1

//file2

double b;

int func3();

{

.

.

}

int func4();

{

.

.

}

//end of file2

Although the variable a has been declared in file1, we want to use it in file2. Placing the statement extern int a in file2, we can extend the scope of the variable a into file2.

Now the scope of the variable a is not only in file1, but also in func3 and func4.

//file1

int a;

float c;

static double d;

.

.

int main()

{

func1();

func2();

func3();

func4();

.

}

extern double b;

int func1();

{

.

.

}

int func2();

{

.

.

}

//end of file1

//file2

double b;

extern int a;

int func3();

{

.

.

}

int func4();

{

extern float c;

.

.

}

//end of file2

Besides, placing the statement extern float c; in func4() extends the scope of this global variable, created in file1, into func4(), and the scope of the global variable b, created in file2, is extended into func1() and func2() by the declaration statement extern double b; placed before func1().

Note:

The mechanism that makes it possible for a C++ function to call itself is that C++ allocates new memory locations for all function parameters and local variables as each function is called. There is a dynamic data area for each execution of a function. This allocation is made dynamically, as a program is executed, in a memory area referred as the stack.

A memory stack is an area of memory used for rapidly storing and retrieving data areas for active functions. Each function call reserves memory locations on the stack for its parameters, its local variables, a return value, and the address where execution is to resume in the calling program when the function has completed execution (return address). Inserting and removing items from a stack are based on last-in/first-out mechanism.

Thus, when the function call factorial(n) is made, a data area for the execution of this function call is pushed on top of the stack. This data area is shown as figure below.

The progress of execution for the recursive function factorial applied with n = 3 is as follows:

During the execution of the function call factorial(3), the memory stack evolves as shown in the figure below. Whenever the recursive function calls itself, a new data area is pushed on top of the stack for that function call. When the execution of the recursive function at a given level is finished, the corresponding data area is popped from the stack and the return value is passed back to its calling function.

Example: Fibonacci numbers:

F(N) = F(N-1) + F(N-2) for N>= 2

F(0) = F(1) = 1

#include<iostream.h>

int fibonacci(int);

int main()

{

int m;

cout <<"Enter a number: ";

cin>> m;

cout <<"The fibonacci of "<<m<<" is: "

<< fibonacci(m)<< endl;

return 0;

}

int fibonacci(int n)

{

if (n<= 1) return 1;

return (fibonacci(n-1)+ fibonacci(n-2));

}

The output of the above program:

Enter a number: 4

The fibonacci of 4 is: 5

In this section, we compare recursion and iteration and discuss why the programmer might choose one approach over the other in a particular situation.

Both iteration and recursion are based on a control structure: Iteration uses a repetition structure; recursion uses a selection structure. Both iteration and recursion involve repetition: Iteration explicitly used a repetition structure while recursion achieves repetition through repeated function calls. Iteration and recursion both involve a termitation test: Iteration terminates when the loop-continuation condition fails; recursion terminates when a base case is recognized. Iteration with counter-controlled repetition and recursion both gradually approach termination: Iteration keeps modifying a counter variable until the counter assumes a value that makes the loop-continuation condtion falil; recursion keeps producing simpler versions of the original problem until the base case is reached. Both iteration and recursion can occur indefinitely: An infinite loop occurs with iteration if the loop-continuation test never become false; infinite recursion occurs if the recursion step does not reduce the problem each time in a manner that converges on the base case.

Recursion has many inconveniences. It repeatedly invokes the mechanism, and consequently the overhead, of function calls. This can be expensive in both CPU time and memory space. Each recursive call causes another copy of the function (actually only the function’s variables) to be created; this can consume considerable memory. Iteration normally occurs within a function, so the overhead of repeated function calls and extra memory assignment is omitted.

Any problem that can be solved recursively can also be solved iteratively (nonrecursively). A recursive approach is normally chosen in preference to an iterative approach when the recursive approach more naturally reflects the problem and results in a program that is easier to understand and debug. Another reason to choose a recursive solution is that an iterative solution is not apparent.

In C++, programmers can use pointers and the dereference operator to simulate call-by-reference. When calling a function with arguments should be modified, the addresses of the arguments are passed. This is normally achieved by applying the address-of operator (&) to the name of the variable whose value will be used. A function receiving an address as an argument must define a pointer parameter to receive the address.

Example

// Cube a variable using call-by-reference

// with a pointer argument

#include <iostream.h>

void cubeByReference( int * ); // prototype

int main()

{

int number = 5;

cout << "The original value of number is " << number;

cubeByReference( &number );

cout << "\nThe new value of number is " << number << endl;

return 0;

}

void cubeByReference( int *nPtr )

{

*nPtr = (*nPtr) * (*nPtr) * (*nPtr); // cube number in main

}

The output of the above propgram:

The original value of number is 5

The new value of number is 125

Notice that the name of an array by itself is equivalent to the base address of that array. That is, the name z in isolation is equivalent to the expression &z[0].

Example

#include<iostream.h>

int main()

{

int z[] = { 1, 2, 3, 4, 5};

cout << “The value return by ‘z’ itself is

the addr “ << z << endl;

cout << “The address of the 0th element of

z is “ << &z[0] << endl;

return 0;

}

The output of the above program:

The value return by ‘z’ itself is the addr 0x0065FDF4

The address of the 0th element of z is 0x0065FDF4

Now, let us store the address of array element 0 in a pointer. Then using the indirection operator, *, we can use the address in the pointer to access each array element.

For example, if we store the address of grade[0] into a pointer named gPtr, then the expression *gPtr refers to grade[0].

One unique feature of pointers is that offset may be included in pointer expression.

For example, the expression *(gPtr + 3) refers to the variable that is three (elements) beyond the variable pointed to by gPtr.

The number 3 in the pointer expression is an offset. So gPtr + 3 points to the element grade[3] of the grade array.

Example

#include <iostream.h>

int main()

{

int b[] = { 10, 20, 30, 40 }, i, offset;

int *bPtr = b; // set bPtr to point to array b

cout << "Array b printed with:\n"

<< "Array subscript notation\n";

for ( i = 0; i < 4; i++ )

cout << "b[" << i << "] = " << b[ i ] << '\n';

cout << "\nPointer/offset notation\n";

for ( offset = 0; offset < 4; offset++ )

cout << "*(bPtr + " << offset << ") = "

<< *( bPtr + offset ) << '\n';

return 0;

}

The output of the above program is:

Array b printed with:

Array subscript notation

b[0] = 10

b[1] = 20

b[2] = 30

b[3] = 40

Pointer/offset notation

*(bPtr + 0) = 10

*(bPtr + 1) = 20

*(bPtr + 2) = 30

*(bPtr + 3) = 40

In C++ we often use character arrays to represent strings. A string is an array of characters ending in a null character (‘\0’). Therefore, we can scan through a string by using a pointer. Thus, in C++, it is appropriate to say that a string is a constant pointer – a pointer to the string’s first character.

A string may be assigned in a declaration to either a character array or a variable of type char *. The declarations

char color[] = “blue”;

char* colorPtr = “blue”;

each initialize a variable to the string “blue”. The first declaration creates a 5-element array color containing the characters ‘b’, ‘l’, ‘u’, ‘e’ and ‘\0’. The second declaration creates pointer variable colorPtr that points to the string “blue” somewhere in the memory.

The first declaration determines the size of the array automatically based on the number of initializers provided in the initializer list.

Example

/* Printing a string one character at a time using a non-constant pointer to constant data */

#include<iostream.h>

int main( )

{

char strng[] = “Adams”;

char *sPtr;

sPtr = &strng[0];

cout << “\nThe string is: \n”;

for( ; *sPtr != ‘\0’; sPtr++)

cout << *sPtr << ‘ ‘;

return 0;

}

The output of the above program:

The string is:

A d a m s

Note: The name of a string by itself is equivalent to the base address of that string.

Complete copies of all members of a structure can be passed to a function by including the name of the structure as an argument to the called function.

Example

#include <iostream.h>

struct Employee // declare a global type

{

int idNum;

double payRate;

double hours;

};

double calcNet(Employee); // function prototype

int main()

{

Employee emp = {6782, 8.93, 40.5};

double netPay;

netPay = calcNet(emp); // pass by value

cout << "The net pay for employee "

<< emp.idNum << " is $" << netPay << endl;

return 0;

}

double calcNet(Employee temp) // temp is of data

// type Employee

{

return (temp.payRate * temp.hours);

}

The output is:

The net pay for employee 6782 is $361.665