EC-102 Computer System &

Programming

Instructor: Jahan Zeb

Department of Computer Engineering (DCE)
College of E&ME
 Functions

 Divide and conquer

– Construct a program from smaller pieces or components
– Each piece more manageable than the original program
 Program Components in C++

 Modules: functions and classes

 Programs use new and “prepackaged” modules
– New: programmer-defined functions,
– Prepackaged: from the standard library
 Functions invoked by function call
– Function name and information (arguments) it needs
 Function definitions
– Only written once
– Hidden from other functions
 Program Components in C++

 Boss to worker analogy

– A boss (the calling function or caller) asks a worker (the
called function) to perform a task and return (i.e., report
back) the results when the task is done.
 Math Library Functions

 Perform common mathematical calculations

– Include the header file <cmath>
 Functions called by writing
– functionName (argument);
or
– functionName(argument1, argument2, …);
 Example
cout << sqrt( 900.0 );
– sqrt (square root) function The preceding statement would
print 30
– All functions in math library return a double
 Math Library Functions

 Function arguments can be

– Constants
• sqrt( 4 );
– Variables
• sqrt( x );
– Expressions
• sqrt( sqrt( x ) ) ;
• sqrt( 3 - 6x );
Me tho d De sc rip tio n Exa m p le
ceil( x ) rounds x to the smallest integer not less than x ceil( 9.2 ) is 10.0
ceil( -9.8 ) is -9.0
cos( x ) trigonometric cosine of x cos( 0.0 ) is 1.0
(x in radians)
exp( x ) exponential function ex exp( 1.0 ) is 2.71828
exp( 2.0 ) is 7.38906
fabs( x ) absolute value of x fabs( 5.1 ) is 5.1
fabs( 0.0 ) is 0.0
fabs( -8.76 ) is 8.76
floor( x ) rounds x to the largest integer not greater than floor( 9.2 ) is 9.0
x floor( -9.8 ) is -10.0
fmod( x, y ) remainder of x/y as a floating-point number fmod( 13.657, 2.333 ) is 1.992

log( x ) natural logarithm of x (base e) log( 2.718282 ) is 1.0

log( 7.389056 ) is 2.0
log10( x ) logarithm of x (base 10) log10( 10.0 ) is 1.0
log10( 100.0 ) is 2.0
pow( x, y ) x raised to power y (xy) pow( 2, 7 ) is 128
pow( 9, .5 ) is 3
sin( x ) trigonometric sine of x sin( 0.0 ) is 0
(x in radians)
sqrt( x ) square root of x sqrt( 900.0 ) is 30.0
sqrt( 9.0 ) is 3.0
tan( x ) trigonometric tangent of x tan( 0.0 ) is 0
(x in radians)
 Functions

 Functions
– Modularize a program
– Software reusability
• Call function multiple times
 Local variables
– Known only in the function in which they are defined
– All variables declared in function definitions are local
variables
 Parameters
– Local variables passed to function when called
– Provide outside information
 Function Definitions

 Function prototype
– Tells compiler argument type and return type of function
– int square( int );
• Function takes an int and returns an int

 Calling/invoking a function
– square(x);
– Parentheses an operator used to call function
• Pass argument x
• Function gets its own copy of arguments
– After finished, passes back result
 Function Definitions

 Format for function definition

return-value-type function-name( parameter-list )
{
declarations and statements
}
– Parameter list
• Comma separated list of arguments
– Data type needed for each argument
• If no arguments, use void or leave blank
– Return-value-type
• Data type of result returned (use void if nothing returned)
 Function Definitions

 Example function
int square( int y )
{

return y * y;
}

 return keyword
– Returns data, and control goes to function’s caller
• If no data to return, use return;
– Function ends when reaches right brace
• Control goes to caller
 Functions cannot be defined inside other functions
 Next: program examples
1
2
3 #include <iostream>
4 Function prototype: specifies
5 using std::cout; data types of arguments and
6 using std::endl; return values. square
7
expects an int, and returns
8 int square( int ); // function prototype
an int.
9
10 int main()
11 { Parentheses () cause function
12 // loop 10 times and calculate and output
to be called. When done, it
13 // square of x each time
14 for ( int x = 1; x <= 10; x++ )
returns the result.
15 cout << square( x ) << " "; // function call
16
17 cout << endl;
18
19 return 0; // indicates successful termination
20
21 } // end main
22
23 // square function definition returns square of an integer
24 int square( int y ) // y is a copy of argument to function
25 {
26 return y * y; // returns square of y as an int
27
28 } // end function square
Definition of square. y is a
copy of the argument passed.
1 4 9 16 25 36 49 64 81 100 Returns y * y, or y squared.
1
2 // Finding the maximum of three floating-point numbers.
3 #include <iostream>
4
5 using std::cout;
6 using std::cin;
7 using std::endl;
8
9 double maximum( double, double, double ); // function prototype
10
11 int main()
12 {
13 double number1;
Function maximum takes 3
14 double number2;
arguments (all double) and
15 double number3;
16
returns a double.
17 cout << "Enter three floating-point numbers: ";
18 cin >> number1 >> number2 >> number3;
19
20 // number1, number2 and number3 are arguments to
21 // the maximum function call
22 cout << "Maximum is: "
23 << maximum( number1, number2, number3 ) << endl;
24
25 return 0; // indicates successful termination
26
27 } // end main
28 Comma separated list for
29 // function maximum definition; multiple parameters.
30 // x, y and z are parameters
31 double maximum( double x, double y, double z )
32 {
33 double max = x; // assume x is largest
34
35 if ( y > max ) // if y is larger,
36 max = y; // assign y to max
37
38 if ( z > max ) // if z is larger,
39 max = z; // assign z to max
40
41 return max; // max is largest value
42
43 } // end function maximum

Enter three floating-point numbers: 99.32 37.3 27.1928

Maximum is: 99.32

Enter three floating-point numbers: 1.1 3.333 2.22

Maximum is: 3.333

Enter three floating-point numbers: 27.9 14.31 88.99

Maximum is: 88.99
 Function Prototypes

 Function prototype contains

– Function name
– Parameters (number and data type)
– Return type (void if returns nothing)
– Only needed if function definition after function call
 Prototype must match function definition
– Function prototype
double maximum( double, double, double );
– Definition
double maximum( double x, double y, double z )
{
…
}
 Function Prototypes

 Function signature
– Part of prototype with name and parameters
• double maximum( double, double, double );
Function signature

 Argument Coercion
– Force arguments to be of proper type
• Converting int (4) to double (4.0)
cout << sqrt(4)
– Conversion rules
• Arguments usually converted automatically
• Changing from double to int can truncate data
– 3.4 to 3
 break and continue Statements

 break statement
– Immediate exit from while, for, do/while, switch
– Program continues with first statement after structure
 Common uses
– Escape early from a loop
– Skip the remainder of switch
1
2 // Using the break statement in a for structure.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 // function main begins program execution
9 int main()
10 {
11
12 int x; // x declared here so it can be used after the loop
13
14 // loop 10 times
15 for ( x = 1; x <= 10; x++ ) { Exits for structure when
16 break executed.
17 // if x is 5, terminate loop
18 if ( x == 5 )
19 break; // break loop only if x is 5
20
21 cout << x << " "; // display value of x
22
23 } // end for
24
25 cout << "\nBroke out of loop when x became " << x << endl;
26
27 return 0; // indicate successful termination
28
29 } // end function main

1 2 3 4
Broke out of loop when x became 5
 break and continue Statements

 continue statement
– Used in while, for, do/while
– Skips remainder of loop body
– Proceeds with next iteration of loop
 while and do/while structure
– Loop-continuation test evaluated immediately after the
continue statement
 for structure
– Increment expression executed
– Next, loop-continuation test evaluated
1
2 // Using the continue statement in a for structure.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 // function main begins program execution
9 int main()
10 {
11 // loop 10 times
12 for ( int x = 1; x <= 10; x++ ) {
13 Skips to next iteration of the
14 // if x is 5, continue with loop.
next iteration of loop
15 if ( x == 5 )
16 continue; // skip remaining code in loop body
17
18 cout << x << " "; // display value of x
19
20 } // end for structure
21
22 cout << "\nUsed continue to skip printing the value 5"
23 << endl;
24
25 return 0; // indicate successful termination
26
27 } // end function main

1 2 3 4 6 7 8 9 10
Used continue to skip printing the value 5
1
2 // Shifted, scaled integers produced by 1 + rand() % 6.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 #include <iomanip>
9
10 using std::setw;
11
12 #include <cstdlib> // contains function prototype for rand
13
14 int main()
15 {
16 // loop 20 times
Output of rand() scaled and
17 for ( int counter = 1; counter <= 20; counter++ ) {
18
shifted to be a number
19 // pick random number from 1 to 6 and output it between 1 and 6.
20 cout << setw( 10 ) << ( 1 + rand() % 6 );
21
22 // if counter divisible by 5, begin new line of output
23 if ( counter % 5 == 0 )
24 cout << endl;
25
26 } // end for structure
27
28 return 0; // indicates successful termination
29
30 } // end main

6 6 5 5 6
5 1 1 5 3
6 6 2 4 2
6 2 3 4 1
 Storage Classes

 Variables have attributes

– Have seen name, type, size, value
– Storage class
• How long variable exists in memory
– Scope
• Where variable can be referenced in program
– Linkage
• For multiple-file program
 Storage Classes

 Automatic storage class

– Variable created when program enters its block
– Variable destroyed when program leaves block
– Only local variables of functions can be automatic
• Automatic by default
• keyword auto explicitly declares automatic
– register keyword
• Hint to place variable in high-speed register
• Good for often-used items (loop counters)
• Often unnecessary, compiler optimizes
– Specify either register or auto, not both
• register int counter = 1;
 Storage Classes

 Static storage class

– Variables exist for entire program
– May not be accessible, scope rules still apply (more later)
 static keyword
– Local variables in function
– Keeps value between function calls
– Only known in own function
 extern keyword
– Default for global variables/functions
• Globals: defined outside of a function block
– Known in any function that comes after it
 Scope Rules

 Scope
– Portion of program where identifier can be used
 File scope
– Defined outside a function, known in all functions
– Global variables, function definitions and prototypes
 Function scope
– Can only be referenced inside defining function
 Scope Rules

 Block scope
– Begins at declaration, ends at right brace }
• Can only be referenced in this range
– Local variables, function parameters
– static variables still have block scope
• Storage duration does not affect scope
 Function-prototype scope
– Parameter list of prototype
– Names in prototype optional
• Compiler ignores
– In a single prototype, name can be used once
1
2 // A scoping example.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 void useLocal( void ); // function prototype
9
Declared outside of function;
void useStaticLocal( void ); // function prototype
10 void useGlobal( void ); global variable prototype
// function with file
11 scope.
12 int x = 1; // global variable
13 Local variable with function
14 int main() scope.
15 {
16 int x = 5; // local variable to main
17
18 cout << "local x in main's outerCreate
scopea is
new" block,
<< x << endl;
giving x
19
block scope. When the block
20 { // start new scope
ends, this x is destroyed.
21
22 int x = 7;
23
24 cout << "local x in main's inner scope is " << x << endl;
25
26 } // end new scope
27
28 cout << "local x in main's outer scope is " << x << endl;
29
30 useLocal(); // useLocal has local x
31 useStaticLocal(); // useStaticLocal has static local x
32 useGlobal(); // useGlobal uses global x
33 useLocal(); // useLocal reinitializes its local x
34 useStaticLocal(); // static local x retains its prior value
35 useGlobal(); // global x also retains its value
36
37 cout << "\nlocal x in main is " << x << endl;
38
39 return 0; // indicates successful termination
40
41 } // end main
42
43 // useLocal reinitializes local variable x during each call
44 void useLocal( void )
45 {
46 int x = 25; // initialized each time useLocal is called
47
48 cout << endl << "local x is Automatic
" << x variable (local
49 << variable
" on entering useLocal" of function). This
<< endl; is
50 ++x; destroyed when the function
51 cout << "local x is " << x exits, and reinitialized when
52 << the <<
" on exiting useLocal" function
endl;begins.
53
54 } // end function useLocal
55
56 // useStaticLocal initializes static local variable x only the
57 // first time the function is called; value of x is saved
58 // between calls to this function
59 void useStaticLocal( void )
60 {
61 // initialized only first time useStaticLocal is called
62 static int x = 50;
63
64 cout << endl << "local static x is " << x
65 << " on entering useStaticLocal" << endl;
66 ++x;
67 cout << "local static x is " << xStatic local variable of
68 << function;
" on exiting useStaticLocal" it is initialized
<< endl; only
69 once, and retains its value
70 } // end function useStaticLocal between function calls.
71
72 // useGlobal modifies global variable x during each call
73 void useGlobal( void )
74 {
75 cout << endl << "global x is " << x This function does not declare
76 << " on entering useGlobal" << endl; any variables. It uses the
77 x *= 10; global x declared in the
78 cout << "global x is " << x
beginning of the program.
79 << " on exiting useGlobal" << endl;
80
81 } // end function useGlobal

local x in main's outer scope is 5

local x in main's inner scope is 7
local x in main's outer scope is 5
 
local x is 25 on entering useLocal
local x is 26 on exiting useLocal
 
local static x is 50 on entering useStaticLocal
local static x is 51 on exiting useStaticLocal

global x is 1 on entering useGlobal

global x is 10 on exiting useGlobal
 
local x is 25 on entering useLocal
local x is 26 on exiting useLocal
 
local static x is 51 on entering useStaticLocal
local static x is 52 on exiting useStaticLocal
 
global x is 10 on entering useGlobal
global x is 100 on exiting useGlobal
 
local x in main is 5
 Functions with Empty Parameter Lists

 Empty parameter lists

– void or leave parameter list empty
– Indicates function takes no arguments
– Function print takes no arguments and returns no value
• void print();
• void print( void );
1
2 // Functions that take no arguments.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 void function1(); // function prototype
9 void function2( void ); // function prototype
10
11 int main()
12 {
13 function1(); // call function1 with no arguments
14 function2(); // call function2 with no arguments
15
16 return 0; // indicates successful termination
17
18 } // end main
19
20 // function1 uses an empty parameter list to specify that
21 // the function receives no arguments
22 void function1()
23 {
24 cout << "function1 takes no arguments" << endl;
25
26 } // end function1
27
28 // function2 uses a void parameter list to specify that
29 // the function receives no arguments
30 void function2( void )
31 {
32 cout << "function2 also takes no arguments" << endl;
33
34 } // end function2

function1 takes no arguments

function2 also takes no arguments