function. introduction library function new defined function random number generator scope inline...
TRANSCRIPT
Function
IntroductionLibrary functionNew defined functionRandom number generatorScopeInline functionFunction overload
FunctionFunction
Why do we need function? Reuse and simplify a large program.
Chapter 7 and Chapter 8 (p309-p436)
IntroductionIntroduction
Library functionLibrary function1 // using library function.
2 #include <iostream>
3 #include <iomanip>
4 5 using namespace std;;
6 7 int main()
8 {9 cout << setw(4) <<123 << endl;
10 11 return 0; // indicates successful termination
12 13 } // end main
14
123
Include the header file Functions called by writing
setw (4);
4 can be replaced by Constants: setw( 5 ); Variables:
X=4; setw(x);
Expressions: X=2; setw( 6-x );
9 int x=4;10 cout << setw(x) <<123 << endl;
9 int x=2;10 cout << setw(6-x) <<123 << endl;
10 cout << setw(5) <<123 << endl;
Math library function Perform common mathematical calculations Include the header file <cmath> Example
cout << sqrt( 900.0 ); sqrt (square root) function The preceding statement would print 30
Method Description Example 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 (x in radians)
cos( 0.0 ) is 1.0
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 x
floor( 9.2 ) is 9.0 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 (x in radians)
sin( 0.0 ) is 0
sqrt( x ) square root of x sqrt( 900.0 ) is 30.0 sqrt( 9.0 ) is 3.0
tan( x ) trigonometric tangent of x (x in radians)
tan( 0.0 ) is 0
Math library functions.
1 // using math library function.
2 #include <iostream>
3 #include <cmath>
4 5 using std::cout;
6 using std::endl;
7 8 int main()
9 {10 // loop 10 times and calculate and output
11 // square root of x each time
12 for ( int x = -5; x <= 5; x++ )
13 cout << abs (x) << “, "; // function call
14 15 cout << endl;
16 17 return 0; // indicates successful termination 18 } // end main
Parentheses () cause function to be called. When the call done, the function result will be provided.
Head file.
5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5,
1 // using math library function.
2 #include <iostream>
3 // do not need any other header file.
4 5 using std::cout;
6 using std::endl;
7 8 int main()
9 {10 // loop 10 times and calculate and output
11 // square root of x each time
12 for ( int x = -5; x <= 5; x++ ) {
13 If ( x <0) cout << -x << “, "; // if else, implementation of abs (x)
14 else cout << x << “, ";
15 }16 cout << endl;
17 18 return 0; // indicates successful termination 19 } // end main
Without function call, the program needs implementation of abs here.
5, 4, 3, 2, 1, 0, 1, 2, 3, 4, 5,
Thinking?In program 1:
Does the function know when it will be called?Is that function reused 11 times in the loop? (Does the name abs appear 11 times?)Do you care how to get absolute number in main?
Comparing with a main program providing a detailed implementation of abs inside that loop, is this main more simple and easier to develop?
No
YesNo
Yes
12 for ( int x = -5; x <= 5; x++ ) {
13 If ( x <0) cout << -x << “, ";
14 else cout << x << “, ";
15 }
12 for ( int x = -5; x <= 5; x++ )
13 cout << abs (x) << “, ";
Program 1 Program 2
New defined functionNew defined function 3 aspects
Function prototype Function call Function definition
Argument and parameter Pre-condition and post-condition Reference parameter Return value How to solve real problems by using
arguments and parameters.
3 aspects3 aspectsFunction prototype
Is used by compiler to check if the function call matches the function definition.
A simple sample:void function-name( );
Calling/invoking a function (function call) A simple call:
function-name(); Parentheses are used to call function (Control
goes to function). When the call done, the program will return to
the point from which the function was called (Control goes back to caller).
3 aspects3 aspectsFunction definition
A simple function definition
void function-name(){ statements}
Simple sample
Function heading, without “;”.
******************************
******************************
Welcome!
******************************
******************************
3 aspects3 aspectsFunction definition
A simple function definition
void function-name(){ declarations and statements}
1 // using new defined function.
2 #include <iostream>
3 using namespace std;
4 void print_star_one_line ( ); 56 int main()
7 {8 print_star_one_line ( ); // print one line of stars.
9 print_star_one_line ( ); // another line
10 cout <<“Welcome!“<<endl;
11 print_star_one_line ( ); // print two lines of stars.
12 print_star_one_line ( );
13 14 return 0; // indicates successful termination 15 } // end main
16 17 void print_star_one_line ( )
18 {19 cout << “******************************“<< endl;
20 } // end of function
Parentheses () cause function to be called in main(). When the function done, the program will do the next statement.
Function prototype.
Function definition. Its statements inside will be executed when the function is called.
A function cannot be defined in other function such like:
17 void print_star_one_line ( )
18 {19 void print_one_star ( )
20 {21 cout << ”*” << end; 22 } // end of function print_one_star
......
.. } // end of function print_star_one_line
******************************
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Welcome!AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ******************************
Thinking?Do we need two different functions?
Argument and parameterArgument and parameter Make function more general by input parameter. With parameter in the function definition, function
call with different value of argument can fulfill similar tasks.
Argument: A variable or expression listed in a function call; Also called actual argument or actual parameter.
Parameter: A variable declared in a function heading; Also called formal argument or formal parameter.
Argument and parameterArgument and parameter Example.
Express the following procedure: Two numbers; add them together; divide by 2. Try 9 and 8 Try 7 and 4
Did you use (x+y)/2 when you want to express the procedure?
Did you use (a+b)/2 when you want to express the procedure?
1 // using list of arguments and parameters, argument promotion.
2 #include <iostream>
3 using namespace std;
4 void showavg ( int, int ); 56 int main()
7 {8 showavg (9, 8);
9 showavg (7, 4);
10 return 0; //successful termination 11 } // end main
12 13 void showavg (int num1, int num2)
14 {15 cout << float(num1 + num2)/2 <<endl;
16 } // end of function
We tried 9 and 8.
We tried 7 and 4
Instead of x and y (or a and b), I used num1 and num2.
Argument and parameterArgument and parameterGeneral format (Prototype, Call, and Definition)
Function prototypeTells compiler argument type. void function-name( Datatype );
Function call function-name( argument );An argument is passed to parameter in function definition
Function definitionvoid function-name( DataType VariableName ){ statements // use VariableName; its value = value of the argument.
}
1 // using argument and parameter.
2 #include <iostream>
3 using namespace std;
4 void print_one_line ( char ); 56 int main()
7 {8 print_one_line (‘*’ ); // print one line of stars.
9 print_one_line (‘A’ ); // print one line of ‘A’s.
10 cout <<“Welcome!“<<endl;
11 print_one_line (‘A’ ); // print another line of ‘A’s.
12 print_one_line (‘*’ ); // print another line of stars.
13 14 return 0; // indicates successful termination 15 } // end main
16 17 void print_one_line ( char ch )
18 {19 Int i;
20 for ( int x = 1; x <= 30; x++ )
21 cout << ch;
22 cout << endl;
23 } // end of function
‘*’ is passed to parameter.
Use parameter ch as a variable. Its value comes from the argument.
ch
main Print_one_line
‘*’
ch‘A’
Sequence Diagram
******************************
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Welcome!AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA ******************************
Argument and parameterArgument and parameterThe value of argument and parameter
Arguments can be constants, variables, and expressions
The argument will be evaluated to match the parameter when the function is called.
Force arguments to be of definition typecout << sqrt(4) //Converting 4 to double (4.0)
The value will be passed to parameter. The parameter is a variable and its value is
according to the argument in different call.
1 // using argument and parameter.
2 #include <iostream>
3 using namespace std;
4 void print_one_line (char ); 56 int main()
7 {8 char c=’A’;
9 print_one_line (‘*’ ); // one line ‘*’.
10 print_one_line (c ); // one line ‘A’.
11 cout <<“Welcome!“<<endl;
12 print_one_line (c+ ’d’- ’c’ ); //one line ‘B’.
13 print_one_line (‘*’ ); // print another line of ‘*’.
14 return 0; // indicates successful termination 15 } // end main
16 17 void print_one_line ( char ch )
18 {19 int i;
20 for ( int x = 1; x <= 30; x++ )
21 cout << ch;
22 cout << endl;
23 } // end of function
Constants, ‘*’ is passed to parameter, one line ‘*’.
Variable, its value ‘A’ is passed to parameter, one line ‘A’.
Expression, its value ‘B’ is evaluated and passed to parameter, one line ‘B’.
ch
main Print_one_line
‘*’
ch‘A’
Sequence Diagram
ch‘B’
constant value
value of variable c
value of expression
******************************
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Welcome!BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB******************************
Argument and parameterArgument and parameterAdvanced format (Prototype, Call, and Definition
for multiple arguments and parameters) Function prototype
void function-name( DataTypeList );The name of the function followed by data types of
arguments. Comma separated list.
Function call function-name( ArgumentList );The arguments are passed to the parameters according to
their positions, left to right.Comma separated list of arguments.
Argument and parameterArgument and parameterAdvanced format (Prototype, Call, and Definition)
Function definitionvoid function-name( ParameterList ){ statements}
If the list is present, it has the following form: DataType Parameter1, DataType Parameter2, …
Comma separated list.
1 // using list of arguments and parameters, argument promotion.
2 #include <iostream>
3 using namespace std;
4 void showavg ( int, int ); 56 int main()
7 {8 char c=’a’;
9 int i=9, j=2;
10 showavg (i, j);
11 showavg (i, 2.5);
12 showavg (c*300, 11);
13 return 0; //successful termination 14 } // end main
15 16 void showavg (int num1, int num2)
17 {18 cout << float(num1 + num2)/2 <<endl;
19 } // end of function
Argument List. The value of i and j, 9 and 2, are passed to num1 and num2.
Datatype List.
5.5
5.5
14555.5
The value of 2.5 (float) will be truncated to 2 and be passed to num2 (int).
Parameter List.
The type of c*300 will be promoted to int because it’s char * int.
Real Case Real Case ((A company and its delivery)
Thinking? For a guy who delivers the product of that company:
Does he know what his job is? (function definition) Does he know what he will deliver? (parameter)
For the company: Does the company knows what the guy will deliver? (argument) Does the company care how he will deliver? (Does the main include
the implementation of its functions?) Does the company need confirm the delivery? (Control goes back to
main or caller when the function is done.)
Company Guy of delivery service
Product = ‘*’His job is to handle (deliver) this ٱ.Control goes back
(delivery confirmation).
‘*’
Call delivery service
Pre-condition and post-conditionPre-condition and post-conditionPre-condition:
To ensure there is no misuse. An assertion that must be true before the function call It may include:
The acceptable range of argument The external resources the function used and their status.
Post-condition: To ensure the expecting result. An assertion that should be true after the function is called. It may include:
The results All the external things this execution can change.
1 // Function void showavg (int, int).
2 // Pre-condition:
3 // Argument: two integer numbers
4 // external resource: None
5 // Post-condition:
6 // result: show the average on screen
7 // external thing changed: Only the monitor.
8 9 void showavg (int num1, int num2)
10 {11 cout << float(num1 + num2)/2 <<endl;
12 } // end of function
void my_function ( ); //function prototype
int main( ){ my_function( ); //function call
return 0;}
void my_function ( ) //function definition{
}
int
k
int x
int k=3, m =4 ;
, int
, m
, int y
Reference parameterReference parameterValue parameter
A parameter that receives a copy of the value of the corresponding argument.
The change of value of this parameter variable in the function won’t change any thing in its caller (main).
ch
main function
‘*’
ch‘A’
Sequence Diagram
ch‘B’
constant value
value of variable c
value of expression
‘*’
‘A’
‘B’
1 // using argument and parameter.
2 #include <iostream>
3 using namespace std;
4 void print_one_line (char ); 56 int main()
7 {8 char c=’A’;
9 print_one_line (‘*’ );
10 print_one_line (c );
11 cout <<“Welcome!“<<endl;
12 print_one_line (c+ ’d’- ’c’ );
13 print_one_line (‘*’ );
14 return 0;
15 } // end main
16 17 void print_one_line ( char ch )
18 {19 int i;
20 for ( int x = 1; x <= 30; x++ )
21 cout << ch;
22 cout << endl;
23 } // end of function
Reference parameterReference parameter A parameter that receives the location of the caller’s
argument (main). The change of value of this parameter variable in the
function will bring the change to main after the function call.
The argument of its function call should be a variable (declared in main).
General format:void function-name( Datatype & ); //prototype
function-name( ArgumentVariable ); //call void function-name( DataType & VariableName )
// definition
ch, i
main Function (char & ch)
‘*’
ch = ‘A’;
Sequence Diagram
variable i
Function ( i )
‘*’
‘A’‘A’
1 // using reference parameter.
2 #include <iostream>
3 using namespace std;
4 void showavg ( int, int, float & ); 5 int main()
6 {7 float cf=1.2;
8 int i=9, j=2;
9 showavg (i, j,cf);
10 cout <<i << endl << cf <<endl 11 return 0; //successful termination 12 } // end main
13 14 void showavg (int num1, int num2 , float & avg)
15 {16 avg = float(num1 + num2)/2;
17 num1 = 2;
18 } // end of function
A variable in main. It will be used as reference argument.
Datatype &
9
5.5
Function call. No & here.
The change of value of reference parameter. This change in function is brought to main by reference parameter.
The change of value of value parameter won’t change
the value of the argument variable i in main.
num1
main showavg
9 2
num2
Sequence Diagram
avg, cf
cf
1. 2
9 2 1.2
num1 num2 avg, cf
2 2 5.5cf
5.5
i j
9 2
i j
ReturnReturn Return results by using reference parameters Return result by using return statement in function
Function prototype Tells compiler return type
int square( int ); Function takes an int and returns an int
Function call
cout << square(x); After finished, passes back result
ReturnReturn Return result by using return statement in function
Function definition
return-value-type function-name( parameter-list ){ statements
return Result;}
Return-value-type: Data type of result returned (use void if nothing returned)
The value of Result will be evaluated and passed back to caller (main).
If no data to return (void), use return;
1 2 // using return statement.
3 #include <iostream>
4 5 using std::cout;
6 using std::endl;
7 8 int square( int ); // function prototype
9 10 int main()
11 {12 // loop 10 times and calculate and output
13 // square of x each time
14 for ( int x = 2; x <= 10; x++ )
15 cout << square( x ) << " "; // function call
16 17 cout << endl;
18 19 return 0; // indicates successful termination
20 21 } // end main
22
Parentheses () cause function to be called. When done, it returns the result.
Function prototype: specifies data types of arguments and return values. square expects int, and returns an int.
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
4 9 16 25 36 49 64 81 100
Definition of square. Returns y * y, or y squared.
1 2 // using reference parameters for several return values.
3 #include <iostream>
4 5 using std::cout;
6 using std::endl;
7 8 void square_and_root( int, int&, float& ); // function prototype
9 10 int main()
11 {12 int s;
13 float r;
14 for ( int x = 2; x <= 5; x++ ) {
15 square_and_root( x, s, r ) ; // function call
16 cout << s << “, " << r << “; "; // show two results
17 }18 cout << endl; 19 return 0; // indicates successful termination
20 21 } // end main
22
Parentheses () cause function to be called. When done, it returns two results in variables s and r.
Function prototype: specifies data types of arguments and return values. Square_and_root expects an int, and returns two results in reference parameters int & and float &.
23 // function definition returns square and square root
24 void square_and_root( int x, int &y, float & z )
25 { 26 y = x* x; // returns square of x as an int
27 z = sqrt(x); // returns square root of x as an float
28 } // end function square
4, 1.4121; 9, 1.73205; 16, 2; 25, 2.23607;
Definition of square. Returns the change of y and z to main by using reference parameter.
24 int square( int y )
25 {
26 return y * y;
27
28 }
24 void square_and_root( int x, int &y, float & z )
25 { 26 y = x* x;
27 z = sqrt(x);
28 }
The function using return statement is easy to read and can return one value to its caller.The function using reference parameter
has a long list of parameters.has a complicated execution.can return more values.
Exercises
1 #include <iostream>
2 using namespace std;
345 int main()
6 {7 for ( int x = 1; x <= 30; x++ )
8 cout << ”*”;
9 cout << endl;
10 for ( int x = 1; x <= 30; x++ )
11 cout << ”*”;
12 cout << endl;
13 cout <<“Welcome!“<<endl;
14 for ( int x = 1; x <= 30; x++ )
15 cout << ”*”;
16 cout << endl;
17 for ( int x = 1; x <= 30; x++ )
18 cout << ”*”;
19 cout << endl;
20 21 return 0;
22 }
1 #include <iostream>
2 using namespace std;
3 void print_one_line ( ); 45 int main()
6 {7 print_one_line ( );
8 print_one_line ( );
9 cout <<“Welcome!“<<endl;
10 print_one_line ( );
11 print_one_line ( );
12 return 0;
13 } // end main
14 15 void print_one_line ( ) // function heading
16 { // function body
17 for ( int x = 1; x <= 30; x++ )
18 cout << ”*”;
19 cout << endl;
20 } // end of function
Function prototype
Function call
Function definition
******************************
******************************
Welcome!
******************************
******************************
******************************
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
Welcome!BBBBBBBBBBBBBBBBBBBBBBBBBBBBBB******************************
1 // using argument and parameter.
2 #include <iostream>
3 using namespace std;
4 void print_one_line (char ); 56 int main()
7 {8 char c=’A’;
9 print_one_line (‘*’ );
10 print_one_line (c );
11 cout <<“Welcome!“<<endl;
12 print_one_line (c+ ’d’- ’c’ );
13 print_one_line (‘*’ );
14 return 0;
15 } // end main
16 17 void print_one_line ( char ch )
18 {19 for ( int x = 1; x <= 30; x++ )
20 cout << ch;
21 cout << endl;
22 } // end of function
Type of argument
Argument
Parameter
Question on page 19: Get the average of two numbers
Two factors: (x+y) /2 (or (a+b)/2)Two argumentsTwo parameter variables
How to solve real problems by using arguments and parameters
1 //using multiple arguments and parameters.
2 #include <iostream>
3 using namespace std;
4 void showavg ( int, int ); 56 int main()
7 {8 showavg (9, 8);
9 showavg (7, 4);
10 return 0; //successful termination 11 } // end main
12 13 void showavg (int num1, int num2)
14 {15 cout << float(num1 + num2)/2 <<endl;
16 } // end of function
The average number is printed out when the function is called every time.How can the caller use the result of function?
1 // using return statement.
2 #include <iostream>
3 using namespace std;
4 float get_avg ( int, int ); 56 int main()
7 {8 cout << get_avg (9, 8) <<endl;
9 cout << get_avg (7, 4) <<endl;
10 return 0; //successful termination 11 } // end main
12 13 float get_avg (int num1, int num2)
14 {15 return float(num1 + num2)/2;
16 } // end of function
Do we need return? Program using return statement
Return statement
Return type
1 // using return statement.
2 #include <iostream>
3 using namespace std;
4 void get_avg ( int, int, float & ); 56 int main()
7 {8 int r;
9 get_avg (9, 8, r );
10 cout << r <<endl;
11 get_avg (7, 4, r );
12 cout << r <<endl;
13 return 0; //successful termination 14 } // end main
15 16 void get_avg (int num1, int num2, float & res)
17 {18 res = float(num1 + num2)/2;
19 } // end of function
Program using reference parameter
Reference parameter
Solution for exercises Get the larger one of two numbers Two factors Two arguments Two parameter variables
1 // using return statement.
2 #include <iostream>
3 using namespace std;
4 int get_larger ( int, int ); 56 int main()
7 {8 int x, y;
9 cin >> x >> y;
10 cout << get_larger (x, y) <<endl; //function call 11 return 0; //successful termination 12 } // end main
13 14 int get_larger (int num1, int num2)
15 {16 if (num1 > num2)
17 return num1;
18 else return num2;
19 } // end of function
“cout <<___ ; //function call” -> function with return statement
1 // using return statement.
2 #include <iostream>
3 using namespace std;
4 int get_larger ( int, int ); 56 int main()
7 {8 int x, y;
9 cin >> x >> y;
10 cout << get_larger (x, y) <<endl;
11 return 0; //successful termination 12 } // end main
13 14 int get_larger (int num1, int num2)
15 {16 return (num1 > num2)? num1: num2;
17 } // end of function
1 // using reference parameter.
2 #include <iostream>
3 using namespace std;
4 void get_larger ( int, int, int & ); 56 int main()
7 {8 int x, y, larger;
9 cin >> x >> y;
10 get_larger (x, y, larger );
11 cout << larger <<endl;
12 return 0; //successful termination 13 } // end main
14 15 void get_avg (int num1, int num2, int & res)
16 {17 res = (num1 > num2)? num1: num2;
18 } // end of function
“cout <<larger;” -> function with reference parameter “larger”.
UsageFormatExample
Random number generatorRandom number generator
Random selection rolling dice, and etc.
rand function (<cstdlib>) i = rand(); Generates unsigned integer between 0 and RAND_MAX
(usually 32767) Generates integer between a and b.
i = rand() % 6 + 1; “Rand() % 6” generates a number between 0 and 5 (scaling) x % y is between 0 and y – 1, i.e., 10 % 3 is 1 “+ 1” makes the range 1 to 6 (shift)
Example: Program to roll dice.
1 // Shifted, scaled integers produced by 1 + rand() % 6.
2 #include <iostream>
3 #include <iomanip>
4 #include <cstdlib> // contains function prototype for rand
5 6 using namespace std;
7 8 int main()
9 {10 // loop 20 times
11 for ( int counter = 1; counter <= 20; counter++ ) {
12 13 // pick random number from 1 to 6 and output it
14 cout << setw( 10 ) << ( 1 + rand() % 6 ); 15 // if counter divisible by 5, begin new line of output
16 if ( counter % 5 == 0 )
17 cout << endl;
18 19 } // end for structure
20 21 return 0; // indicates successful termination
22 } // end main
Output of rand() scaled and shifted to be a number between 1 and 6.
Head file.
6 6 5 5 6
5 1 1 5 3
6 6 2 4 2
6 2 3 4 1
Thinking
Is this fair?
1 // Roll a six-sided die 6000 times.
2 #include <iostream>
3 #include <iomanip>
4 #include <cstdlib> // contains function prototype for rand
5 6 using namespace std;
7 8 int main()
9 {10 int frequency1 = 0;
11 int frequency2 = 0;
12 int frequency3 = 0;
13 int frequency4 = 0;
14 int frequency5 = 0;
15 int frequency6 = 0;
16 int face; // represents one roll of the die
17
18 // loop 6000 times and summarize results
19 for ( int roll = 1; roll <= 6000; roll++ ) {
20 face = 1 + rand() % 6; // random number from 1 to 6
21 22 // determine face value and increment appropriate counter
23 switch ( face ) {
24 case 1: // rolled 1
25 ++frequency1;
26 break;
27 case 2: // rolled 2
28 ++frequency2;
29 break;
30 case 3: // rolled 3
31 ++frequency3;
32 break;
33 case 4: // rolled 4
34 ++frequency4;
35 break;
36 case 5: // rolled 5
37 ++frequency5;
38 break;
39 case 6: // rolled 6
40 ++frequency6;
41 break;
42 default: // invalid value
43 cout << "Program should never get here!";
44 45 } // end switch
46 47 } // end for
48 49 // display results in tabular format
50 cout << "Face" << setw( 13 ) << "Frequency"
51 << "\n 1" << setw( 13 ) << frequency1
52 << "\n 2" << setw( 13 ) << frequency2
53 << "\n 3" << setw( 13 ) << frequency3
54 << "\n 4" << setw( 13 ) << frequency4
55 << "\n 5" << setw( 13 ) << frequency5
56 << "\n 6" << setw( 13 ) << frequency6 << endl;
57 58 return 0; // indicates successful termination
59 60 } // end main
Default case included even though it should never be reached. This is a matter of good coding style
Face Frequency
1 1003
2 1017
3 983
4 994
5 1004
6 999
Calling rand() repeatedly Gives the same sequence of numbers To get different random sequences
Provide a seed value• Like a random starting point in the sequence• The same seed will give the same sequence
srand(seed); • <cstdlib>• Used before rand() to set the seed
1 // Randomizing die-rolling program.
2 #include <iostream>
3 #include <iomanip>
4 #include <cstdlib>
5 using namespace std;
6 7 int main()
8 {9 unsigned seed;
10 11 cout << "Enter seed: ";
12 cin >> seed;
13 srand( seed ); // seed random number generator
14 // loop 10 times
15 for ( int counter = 1; counter <= 10; counter++ ) {
16 // pick random number from 1 to 6 and output it
17 cout << setw( 10 ) << ( 1 + rand() % 6 );
18 // if counter divisible by 5, begin new line of output
19 if ( counter % 5 == 0 )
20 cout << endl;
21 } // end for
22 return 0; // indicates successful termination
23 } // end main
Setting the seed with srand() before rand().
Enter seed: 67
6 1 4 6 2
1 6 1 6 4
Enter seed: 432
4 6 3 1 6
3 1 5 4 2
Enter seed: 67
6 1 4 6 2
1 6 1 6 4
rand() gives the same sequence if it has the same initial seed.
Can use the current time to set the seed Use current time as seedsrand( time( 0 ) );time( 0 );
• <ctime>• Returns current time in seconds
Number = shiftingValue + rand() % scalingFactor
• shiftingValue = first number in desired range• scalingFactor = width of desired range
1 // Shifted, scaled integers produced by 1 + rand() % 6.
2 #include <iostream>
3 #include <iomanip>
4 #include <cstdlib> // contains function prototype for rand
5 #include <ctime> // contains function prototype for time
6 using namespace std;
7 8 int main()
9 {10 srand ( time( 0 ));
11 for ( int counter = 1; counter <= 20; counter++ ) {
12 13 // pick random number from 1 to 6 and output it
14 cout << setw( 10 ) << ( 1 + rand() % 6 ); 15 // if counter divisible by 5, begin new line of output
16 if ( counter % 5 == 0 )
17 cout << endl;
18 19 } // end for structure
20 21 return 0; // indicates successful termination
22 } // end main
Use current time as seed.
1 1 1 3 3
1 4 5 6 6
5 2 3 6 1
1 5 6 3 3
1 5 2 1 4
2 2 3 5 2
4 6 1 3 5
5 5 6 5 2
IntroductionLocal scopeGlobal scopeName precedenceStatic variable
ScopeScope
num1
main
showavg
9 2
cf
1. 2
cf
5.5
i j
avg
Lifetime
num2
5.5
Introduction (Lifetime)Introduction (Lifetime)
9 2
5 int main()
6 {7 float cf=1.2;
8 int i=9, j=2;
9 showavg (i, j,cf);
10 cout <<i << endl << cf <<endl 11 return 0; //successful termination 12 } // end main
13 14 void showavg (int num1, int num2 , float & avg)
15 {16 avg = float(num1 + num2)/2;
17 num1 = 2;
18 } // end of function
Introduction (scope)Introduction (scope)Scope
Portion of program where identifier can be used.
Local scopeGlobal scope
Local scopeLocal scopeLocal variables, function parametersScope begins at declaration, ends at right
braceVariable created when program enters its
blockVariable invalid when program leaves blockVariable destroyed when program reaches
the right brace of this block
1 // using arguments and parameters.
2 #include <iostream>
3 using namespace std;
4 void showavg ( int, int, float & ); 5 int main()
6 {7 float cf=1.2;
8 int j;
9 for ( j = 1; j <= 5; j++ ) {
10 int i = 9;
11 showavg( i, j, cf ) ; // function call
12 cout <<i << endl << cf <<endl 13 }14 return 0; //successful termination 15 } // end main
16 17 void showavg (int num1, int num2 , float & avg)
18 {19 avg = float(num1 + num2)/2;
20 } // end of function
num1
i
Local scope starts from declaration
Local variable will be invalid when the program leaves main for showavg.
Create a new block, giving i block scope. When the block ends (the program reaches the right brace of the block), this i is destroyed.
{
…………
int i;i=i+1;…………
}
{int i;…………
i=i+1;…………
}
int i;i = i+2;
Global scopeGlobal scopeGlobal variables (constants), function
definitions and prototypesDefined outside of any function in a fileScope begins at declaration, ends at the
end of this fileVariable created when program startsVariable is valid from its declaration to the
end of this file.Variable destroyed when program ends
1 // using global variables.
2 #include <iostream>
3 using namespace std;
4 5 double c_area( int );
6 const double pi = 3.14;
7 8 int main()
9 {10 cout << “When pi is " << pi <<endl;
1112 for ( int x = 1; x <= 10; x++ )
13 cout << c_area( x ) << " ";
14 cout << endl;
15 return 0;
16 } // end main
17 18 double c_area( int radius)
19 {
20 return radius * radius * pi;
21 } // end function square
1 // using global variables.
2 #include <iostream>
3 using namespace std;
4 5 const double pi = 3.14;
67 double c_area( int radius)
8 { 9 return radius * radius * pi;
10 } // end function square
11 12 int main()
13 {14 cout << “When pi is " << pi <<endl;
1516 for ( int x = 1; x <= 10; x++ )
17 cout << c_area( x ) << " ";
18 cout << endl;
19 return 0;
20 } // end main
21
Thinking
Local GlobalWhen is it created?When is it destoried?
Is it still valid when thecontrol goes out of the local block?
- - End of local End of fileblock
No Yes
Name precedenceName precedenceWhen a function declares a local identifier
with the same name as a global identifier, the local identifier takes precedence within the function.
The precedence that a local identifier in a function has over a global identifier with the same name in any references that the function makes to that identifier; also called name hiding.
1 // using name precedence.
2 #include <iostream>
3 using namespace std;
4 5 double c_area( int );
6 const double pi = 3.14;
7 8 int main()
9 {10 cout << “When pi is " << pi <<endl;
1113 cout << c_area(10 ) << " ";
14 cout << endl;
15 return 0;
16 } // end main
17 18 double c_area( int radius)
19 {
20 int pi = 3;
20 return radius * radius * pi;
21 } // end function square
pi
3.14
pi
3
main
c_area
When pi is 3.14
300
Static variableStatic variableVariables exist for entire programStatic local variables in function
Keeps value between function calls Variable created once when program first
entered the function Only known in own function Variable destroyed when program ends
1 // using local static.
2 #include <iostream>
3 using namespace std;
4 void useStaticLocal( )
5 6 int main()
7 {8 for ( int x = 1; x <= 10; x++ )
9 useLocal( );
10 return 0;
11 } // end main
12 13 void useLocal ( )
14 {15 // initialized only first time useStaticLocal is called
16 int y = 50;
17 18 cout << "local x is " << y ++ << endl;
19 } // end function useStaticLocal Local variable of function; it is initialized every time when the program call this function.
Y=50
main
useLocal
51
Y=50
useLocal
51
Y=50
useLocal
51
…
local x is 50
local x is 50
local x is 50
local x is 50
local x is 50
local x is 50
local x is 50
local x is 50
local x is 50
local x is 50
1 // using local static.
2 #include <iostream>
3 using namespace std;
4 void useStaticLocal( )
5 6 int main()
7 {8 for ( int x = 1; x <= 10; x++ )
9 useStaticLocal( );
10 return 0;
11 } // end main
12 13 void useStaticLocal ( )
14 {15 // initialized only first time useStaticLocal is called
16 static int y = 50;
17 18 cout << "local static x is " << y ++ << endl;
19 } // end function useStaticLocal Static local variable of function; it is initialized only once, and retains its value between function calls.
Y=50
main
useStaticLocal
51
useStaticLocal
52
useStaticLocal
53
…
local static x is 50
local static x is 51
local static x is 52
local static x is 53
local static x is 54
local static x is 55
local static x is 56
local static x is 57
local static x is 58
local static x is 59
Inline functionInline functionInline functions
Keyword inline before function Asks the compiler to copy code into program
instead of making function call Reduce function-call overhead Compiler can ignore inline
Good for small, often-used functions
Exampleinline double cube( const double s )
{ return s * s * s; }
const tells compiler that function does not modify s
1 // Using an inline function to calculate.
2 #include <iostream>
3 using namespace std;
4 5 // Definition of inline function cube. Definition of function
6 // appears before function is called, so a function prototype
7 // is not required. First line of function definition acts as
8 // the prototype.
9 inline double cube( const double side )
10 { 11 return side * side * side; // calculate cube
12 } // end function cube
13 14 int main()
15 {16 double sideValue;
17 cout << "Enter the side length of your cube: ";
18 cin >> sideValue;
19 // calculate cube of sideValue and display result
20 cout << "Volume of cube with side "
21 << sideValue << " is " << cube( sideValue ) << endl;
22 return 0; // indicates successful termination
23 } // end main
Enter the side length of your cube: 3.5
Volume of cube with side 3.5 is 42.875
Function overloadingFunction overloadingFunction overloading
Functions with same name and different parameters More general, should perform similar tasks
I.e., function to square ints and function to square floats
int square( int x) {return x * x;}
float square(float x) { return x * x; }
Overloaded functions distinguished by signature Based on name and parameter types (order matters)
1 // Using function overloading to calculate.
2 #include <iostream>
3 using namespace std;
4 5 inline double square ( const double side )
6 { 7 cout << “double “;
8 return side * side; // calculate double square
9 } // end function square
10 11 inline int square ( const int side )
12 {
13 cout << “integer “;
14 return side * side; // calculate int square
15 } // end function square
16 17 int main()
18 {19 // calculate squre of sideValue and display result
20 cout << “Square with side 2 is " << square( 2 ) << endl;
21 cout << “Square with side 3.2 is " << square( 3.2 ) << endl;
22 return 0; // indicates successful termination
23 } // end main
The proper function is called based upon the argument (int or double).
Square with side 2 is integer 4
Square with side 3.2 is double 10.24
1 // Fig. 3.4: fig03_04.cpp
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;
14 double number2;
15 double number3;
16 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
Function maximum takes 3 arguments (all double) and returns a double.
26 27 } // end main
28 29 // function maximum definition;
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 } // end function maximum
Enter three floating-point numbers: 99.32 37.3 27.1928Maximum is: 99.32
Enter three floating-point numbers: 1.1 3.333 2.22Maximum is: 3.333
Enter three floating-point numbers: 27.9 14.31 88.99Maximum is: 88.99
Comma separated list for multiple parameters.