Predefined Functions Revisited

 what is?
 function
 function name
 argument(s)
 return value
 function call
 function invocation
 nested function call
 what are predefined functions?
 what is the type of arguments and the type of return value and why are they important?
 what is include directive and how is it related to predefined functions? linker?
 what are type changing functions and why are they needed?
 what is type casting? coersion?
 what does function time() do?
 what do functions rand() and srand() do? what is a seed? why is seed important for
random number generator?
 what is RAND_MAX? how does one get a random number in a desired range?

1
Programmer-Defined Functions

your own code

 Function Invocation (review)
 named group of statements carrying out a particular task
 to carry out its task the function accepts arguments
 to use a function the programmer writes the function name and a list of
arguments for the function to use. This is called function call (or function
invocation)
 every function returns a result in a return value
 a function call can be used in any place an expression or statement is used
 if a function is used as an expression - the function evaluates to its return
value
 if a function is used as a statement - the return value is ignored
 arguments and return value of a function are of specified type
 two kinds of functions:
 predefined - provided in libraries for the benefit of all programmers
 programmer-defined - written by programmer

3
 Function Invocation Semantics
argument

cout << add1(4+5)+6 << endl;

invocation
 caller – function that invokes another
 callee – function that is being invoked
 processing a function invocation: caller is suspended, callee is
executed, callee computes the return value which substitutes invocation
in the caller
 if invocation is inside an expression, the return value is used to
evaluate the expression

4
 Function Definition
 function definition – specifies instructions that the function executes
 consists of head, body

return type function name parameter

double circleArea (double r) {

const double pi = 3.1415;
return pi * r * r; function head
}

function body
return statement

5
 Parameters and return-statement
 programmer defined function cannot know what arguments will be passed to it;
it uses (formal) parameters
 parameters - local variables of the callee that are initialized to the value of
arguments at invocation

 return-statement specifies what value the function returns:

syntax: return expression;
 the expression is evaluated, coerced to the type specified in function head,
terminates function
 a return-statement is optional. If a function does not have a return-
statement it terminates when the last statement is executed. The return-
value is unspecified
 it is possible to have multiple return-statements. However, putting a return
someplace deep in function code is bad style. Try to code a single return or
obvious returns.

6
 Function Prototype
 function prototype – declares (quickly introduces) the function
returnValue functionName(type parameterName,…,);
 expanded form – mentions parameter types and names: names are optional
but sometimes desirable for clarity
int add1(int i);
 abbreviated form – mentions only parameter types

int add1(int);
 before function invocation, the compiler needs to see either its definition or
prototype
 unlike variables, the function definitions and function prototypes should be put
outside any other function: no nested functions in C++ standard
 it is (almost) possible to write a program without prototypes: put function
definitions before invocations
 such program is hard to understand: more detailed functions would be ahead
in file
 better program style - put function prototypes first, then main(), then other
functions with increasing level of detail
7
 Commenting Functions
 treat a function prototype as a variable definition:
append a short inline description of the function
 precede a function definition with at least one line of
comments explaining the purpose of the function,
possibly comment on parameters

8
 Function Terms Quick Review
what are the terms for the constructs in gray boxes?

double circleArea(double r); // computes circle area

// manage circle computation

int main() {
cout << "Enter radius: ";
double radius; // circle radius
cin >> radius;
const double area = circleArea(radius);
cout << "Circle has area " << area << endl;
}

// computes area of radius r circle

double circleArea(double r) {
const double pi = 3.1415;
return pi * r * r;
}
9
Simple Program Structure
 include statements
 using statements
 function prototypes
 function definitions
 main()
 rest with increasing order of
detail

10
 Local Variables
variable that is declared inside a function is local (to that function): it cannot
be used outside of the function
 the scope of such variable is from declaration till end of function
 parameters are also local variables
 local variables of two different functions are different even if they have the
same name
 variables declared in main() are local to main()

example
// computes sum of integers in a..b
int sum(int a, int b) { // a and b are local
int total = 0; // this is a local variable
for (int i = a; i <= b; ++i) { // i is local to for
total += i;
}
return total;
}

11
 Global Constants and Variables
 constant or variable declared inside a function is local to this function
 global constant – a constant declared outside any function definition
 it can be used (its scope is) anywhere in the program from the place
it is declared

 global variable – variable declared outside any function definition

int errorcode = 0;
 global variable scope is any function of the program from variable
declaration down, functions can read and update global variable
 using global variables introduces side effects to functions

– what's "side effect" gain?

– makes program hard to understand: avoid!

12
 Call-by-Value
 parameters are local variables of the function
 when the function is called, the values of the arguments are evaluated and assigned to respective parameters
 as any local variable, the value of a parameter can be changed in a function
 this change does not affect the values of the original arguments
 such discipline of parameter passing is call-by-value

int add1(int i) {
++i;
return i;
}
...
int n=5;
int newn = add1(n); // value of n is unchanged

13