Building Programs from Existing Information

• Solutions for programs often can be developed from previously solved problems.

• Data requirements and solution algorithm provide a programming starting point.

• Data requirements convert into macro definitions and variable declarations.

• Initial algorithm and refinements become comments for lines in main program.

• Place the C++ code for each unrefined step directly under that commented step.

• When program is completed, test with appropriate data and check correctness.

Library Functions

• Code reuse recycles code that has been already written, debugged and tested.

• C++ has many predefined functions that take argument(s) and return some value.

• Functions are stored in libraries and activated by writing a function call.

Example: y = sqrt(x); uses x as input argument, assigns y to the

value of the square root of x.

User-Defined Functions

• Functions can be written by users to perform frequently needed calculations.

• These functions can either be inserted directly into programs, or

• stored in header files or libraries and then compiled with the calling programs.

Function• The function data area is an area of memory that is

allocated each time the function is called, and is lost when the function terminates.

• This data area holds the function's formal parameters, and local variables created within.

• Variables created inside a function are local to that function, and can be used only inside that function. They are not directly accessible from main.

• Functions can be tested externally by building a driver program that defines the function arguments, calls the function, and displays the values returned.

Functions

• A function is like a robot.• It can receives a list of arguments.• It can returns a value.

Examples of functionsint main (){ int a; a = f(3,4); return 0;}

int f(int x, int y){ return (x + y);}

return (x+y)

f(int x, int y)main ()

Examples of functionsint main (){ int a; a = f(3,4); return 0;}

int f(int x, int y){ return (x + y);}

return (x+y)

f(int x, int y)main ()

3, 4

Examples of functions

F(int x, int y)Main ()

int main (){ int a; a = f(3,4); return 0;}

int f(int x, int y){ return (x + y);}

return (x+y)

3, 4

7

A function calls another functionint main (){ int a; a = f(3,4); return 0;}

int f(int x, int y){ return (x + g(y));}

int g(int a){ return (a + 3);}

3, 4

main

g

f

A function calls another functionint main (){ int a; a = f(3,4); return 0;}

int f(int x, int y){ return (x + g(y));}

int g(int a){ return (a + 3);}

3, 4

main

g

f

4

A function calls another functionint main (){ int a; a = f(3,4); return 0;}

int f(int x, int y){ return (x + g(y));}

int g(int a){ return (a + 3);}

3, 4

main f

4

7g

A function calls another functionint main (){ int a; a = f(3,4); return 0;}

int f(int x, int y){ return (x + g(y));}

int g(int a){ return (a + 3);}

3, 4

main f

10

Function prototype• A function must be declared before it can be

referenced.• One way to declare a function is to insert a

function prototype before the main function.• Function prototype tells the C++ compiler the

function name, data types of the function and the arguments, the correct number of arguments, and the correct order of arguments.

• The data type of a function is determined by the type of value returned by the function.

• It does not specify the function operation. You need to provide a definition for each function.

Function definition and function prototype // A programmer-defined square function #include <iostream>

int square (int); // Function prototype int main() { int x; for (x = 1; x <= 10; x++) cout << square(x) << ‘ ‘; cout << endl; return 0; } int square (int y) // Function definition { return y * y; }

Example• square function gets the value of x.• square function calculates x * x.• The result is passed back to the cout function.• cout function displays the result.• This process is repeated ten times using the for

repetition structure.

Result 1 4 9 16 25 36 49 64 81 100

Function without argument

Example: void display_information(void);

• The function display_information is a void function, returns nothing.

• Second void indicates that display_information expects no arguments.

Function with argument

Example: int square(int); // prototype

• The int in parenthesis informs the compiler that function square expects to receive an integer value from the caller.

• The int to the left of square informs the compiler that it returns an integer result to the caller.

Void function with input argument Example: void display_even_num(int start, int end); // prototype

• The int in parenthesis informs the compiler that function display_even_num expects to receive two integer values from the caller.

• The void to the left of the function display_even_num informs the compiler that it returns nothing to the caller.

#include <iostream>

void display_even_number( int start, int end );

int main()

{

int first, last;

first = 2, last = 20;

display_even_number(first, last);

return 0;

}

void display_even_number( int start, int end)

{

int count;

for( count = start; count <= end; count = count + 2)

cout << count << ' ';

cout << endl; }

Void function with input argument

Argument list correspondence• You should be careful to include the correct number of

arguments in the function call.– Example: int add (int num1, int num2); // prototype y = add (num1, num2); // function call y = add (num1) // incorrect

• The order of the actual arguments used in the function call must correspond to the order of the formal parameters listed in the function prototype.

– Example: int subtract (int num1, int num2); // prototype y = subtract (num1, num2); // function call y = subtract (num2, num1) // incorrect

Argument list correspondence• Usually, each actual argument must be of the same data

type as the corresponding formal parameter. • When an int is assigned to a type double variable, it will

not cause any problem since there is no loss of information.

– Example: – double add (double num1, double num2); //prototype – y = add (num1, num2); // function call with int values: num1 = 2 , num2 = 3

result: Y = 5.0 No loss of information

Argument list correspondence

• When we pass an actual argument of type double to a formal parameter of int, loss of the fractional part of the actual argument can lead to an unexpected result.

– int add (int num1, int num2); // prototype y = add (num1, num2); // function call, num1 = 2.2, num2 = 3.6 result: Y = 5 Loss of information

Advantages of using function

• Code reuse. - using existing function as building blocks to create new programs.

• Divide-and-conquer approach makes program development more manageable.

• Avoid repeating code in a program. We can execute a block of code simply by calling the function many times in a program.

Call by value

• Two ways to invoke functions:– Call by value– Call by reference• Call by value: When arguments are passed call by value, – a copy of the argument’s value is made and passed

to the called function. – Changes to the copy do not affect an original

variable’s value in the caller.

Call by reference

When an argument is passed by reference, • the caller actually allows the called

function to modify the original variable’s value.

• It is possible to simulate call by reference by using address operators and indirection operators.

Cube a variable using call by value #include <iostream> int cubeByValue(int); int main() { int number = 5; cout << “The original value of number is “<< number <<endl; number = cubeByValue(number); cout << “The new value of number is “<< number << endl; return 0; } int cubeByValue(int n) { return n * n * n; }

Cube a variable using call by reference #include <iostream> void cubeByReference(int *); int main() { int number = 5; cout << “The original value of number is “<< number <<endl; cubeByReference(&number); cout << “The new value of number is “<< number << endl; return 0; } void cubeBy Reference(int *nPtr) { *nPtr = *nPtr ** nPtr * *nPtr; }

Header Files Each standard library has a corresponding header file

containing • the function prototypes for all the functions in that

library and • definitions of various data types and constants needed

by those functions.Example:Standard library header file

<stdio.h> Contains function prototypes for the standard input/output library functions, and information used by them.

Storage duration• Period during which an identifier exists in

memory.• Some identifiers exists briefly. • Some are repeatedly created and destroyed.• Others exist for the entire execution of a

program.• Storage duration can be of two types:– automatic (auto and register)– static

Storage Classes• C provides four storage classes indicated by

the storage class specifiers:– auto– register– extern– static• An identifier’s storage class helps

determine its storage duration, scope, and linkage.

Scope• The scope of an identifier is the portion of

the program in which the identifier can be referenced.

• Some identifiers can be referenced throughout the program.

• Others can be referenced from only portions of a program.

• Example: When we declare a local variable in a block,

it can be referenced only in that block or in blocks nested within that block.

Linkage

• An identifier’s linkage determines for a multiple-source-file program where an identifier is known only

– in the current source file or – in any source file with proper declaration.