1. Function
Topic 4

2. Functions A function is a subprogram that performs a specific task.
Functions you know:
cout << “Hi”;
cin >> number;
Functions 2

3. Pre-defined and User-defined Functions
Pre-defined Function
Is a function that is already defined in one of the many C libraries.
It is included in the program through the preprocessor directive
statement #include< > and used in the program to perform a
specific task.
Ex: #include<iostream>
Defines printf & scanf functions
User-defined Function
Is a function that is created by the user.
It is defined before the main program through a function prototype
and called upon in the main program to perform a specific task.
Functions 3

4. Pre-defined Functions
Arithmetic Functions
Are functions that perform arithmetic operations.
They are usually located in the cmath libraries.
(see page 109).
Examples:
abs(x) is a function that returns the absolute value of its integer
argument.
sqrt(x) is a function that returns the square root of x.
Functions 4 6

5. Pre-defined Functions
Function call in an Assignment Statement
Syntax
Y = function name(argument);
Example
Y = sqrt(x);
function call x y
square root
computation
function sqrt
Functions 5

6. Pre-defined Functions
Examples
x = -5
y = abs(x)
y = 5
x = 90
y = abs(x) + 2
y = 92
x = 10
y = sqrt(x + 6)
y = 4
x = 2.25
y = sqrt(x)
y = 1.25
Functions 6

7. Types of Functions
1. Program sends data to the function and receives data from the
function.
Ex. y=sqrt(x); x y
sqrt
2. Program sends data to the function and doesn’t receive data from
the function.
Ex. cout << “Hi”;
“Hi”
cout
Functions 8

8. Types of Functions (Continue)
3. Program doesn’t sends data to the function and receives data from
the function.
Ex. Number = Get_Number();
Get_Number
Number
4. Program doesn’t sends data to the function and doesn’t receive
data from the function.
Ex. Display_Comment();
Display_Comment
Functions 9

9. Top-Down Design (Continue)
Functions 11

10. Advantages of Writing Functions
1. Decreases the main program’s length and reduces the chance to
make errors.
2. Makes it easier to define programming tasks between
programmers. Each programmer can be responsible for a particular
set of functions.
3. Allows procedural abstraction; a programming technique in
which a main function consists of a sequence of function calls and
each function is implemented separately. This helps to focus on one
function at a time instead of writing the complete program all at
once.
4. Allows code reuse of function programs.
Functions 13

11. Code Reuse
Reusing program fragments that have already been written and
tested whenever possible.
It is a way to help in writing error free code.
Functions 14

12. User-defined Functions
Function Prototype
A way to declare a function.
This tells the compiler:
The name of the function
The data type of received data(if there is).
The type & name of sent data (if there is). Also called the
parameters of the function.
defines a function called drawcircle
with not sent nor received data
(when the program doesn’t send to the
function and doesn’t receive from the
function, the function is called a void
function)
Syntax
ftype fname ();
Example
void drawcircle();
Functions 3

13. User-defined Functions
Function Call
A function call transfers control from the main program to the
function or subprogram.
Syntax
fname ();
Example
calls function drawcircle and causes it to begin execution
Drawcircle();
Functions 4

14. User-defined Functions
Function Definition
Defines the function operation by writing the code for the function
in a similar way to writing the code for the main program.
Syntax
Ftype fname(void)
{ local declaration
executable statements }
does not contain the return statement
because this function will not send any
data to the program “main function”
(i.e. a function should contain the
return statement only if it is going to send data to the program)
Example
void drawcircle(void)
{ cout << “ *** ”<<endl;
cout << “* *”<<endl;
cout << “ *** ” endl; }
Functions 5

15. User-defined Functions
Main Program
void drawcircle );
int main() {
drawcircle(); }
void drawcircle ()
Function Prototype
Function Call
Function Definition
Functions 5 6

16. User-defined Functions
Main Program
void drawcircle ();
void drawcircle () { }
int main()
drawcircle();
Function Prototype
Function Definition
Function Call
Functions 7

17. User-defined Functions
Order of Execution
void function1 ();
void function2 ();
int main() {
function1();
function2(); }
{ }
transfer of control back to program
transfer of control to function1
transfer of
control back to program
transfer of control to function2
Functions

18. Example - Drawing a Stick Figure*
* *
* *
/ \
/ \
/____\
/ \
Functions

19. Example - Drawing a Stick Figure
/* draws a stick figure */
#include <iostream>
using namespace std;
void draw_circle(); /* Function prototype */
void draw_intersect(); /* Function prototype */
void draw_base(); /* Function prototype */
void draw_triangle(); /* Function prototype */
int
main(void)
{ draw_circle(); /* function call */
draw_triangle(); /* function call */
draw_intersect(); /* function call */
return(0); }
void draw_circle() /* Function definition */
{ cout << " * “ << endl;
cout << "* *“ << endl;
cout << " * * “<<endl;} (continued)
Functions

20. Example - Drawing a Stick Figure - Continue
/* draws a stick figure - continue*/
void draw_intersect() /* Function definition */ {
cout << " /\\ “ << endl;
cout << " / \\ “ << endl;;
cout << "/ \\“ << endl; }
void draw_base() /* Function definition */
cout << "------“ << endl;
void draw_triangle() /* Function definition */
draw_intersect();
draw_base();
Functions

21. Using Functions
1. Declare a function before the main program.
2. Call the function inside the main program.
3. Define a function after the main program.
Functions 2

22. Review of Syntax
Function Prototype & definition
an identifier that represents a corresponding actual argument in a function definition.
Ex. int square(int x)
Formal Parameter List
ftype fname (data type name, ...);
Function Call
An expression used inside the parentheses of a function call
Ex. square(x)
Actual Argument List
fname (data type name, ...);
Functions 3

23. Rules for Argument List
1. The number of actual arguments used in a function call must be
the same as the number of the formal parameters listed in the
function prototype and definition.
2. The Order of the arguments in the lists determines correspondence
and must be the same in arguments and parameters.
The first actual argument corresponds to the first formal parameter,
the second actual argument corresponds to the second formal
parameter and so on.
3. The data types of the actual argument and the formal parameter
must match.
Functions 4

24. Example
Prototype& definition:
double squared (int x, double y)
What is returned from
the function (i.e. result)
What is sent to the function
Call:
y = squared (x,y)
Functions 5

25. Types of Functions
1. Program sends data to the function and receives data from the
function.
Prototype & definition: return_type function_name (parameter list)
Call: variable_name = function_name (argument list)
2. Program sends data to the function and doesn’t receive data from
the function.
Prototype & definition: void function_name (parameter list)
Call: function_name (argument list)
Functions 6

26. Types of Functions (Continue)
3. Program doesn’t sends data to the function and receives data from
the function.
Prototype & definition: return_type function_name (void)
Call: variable_name = function_name ()
4. Program doesn’t sends data to the function and doesn’t receive
data from the function.
Prototype & definition: void function_name (void)
Call: function_name ()
Functions 7

27. Examples of Function Prototype & definition
float squared (int number)
Returns back a float type
to the main program
An integer type called number is sent
to the function squared
Void print_report (int report_number)
Returns nothing
to the main program
An integer type called report_number
is sent to the function print_report
Functions 8

28. Examples of Function Prototype & definition
char get_menu_choice ()
Returns back a character type to the main program
Nothing is sent to the function
get_menu_choice
Void print_comment ()
Returns nothing
to the main program
Nothing is sent to the function
print_comment
Functions 9

29. Program Example 1
/* computes half of the value of x */
float half_of(float k); /* function prototype */
int
main() {
y=half_of(x); /* calling function */ }
float half_of(float k) /* function definition */
k = k / 2;
return(k);
Functions 10

30. Program Example 2
/* computes the cube of num */
int cubed(int x); /* function prototype */
int
main() {
y=cubed(num); /* calling function */ }
int cubed(int x) /* function definition */
return(x*x*x);
Functions 11

31. Program Example 3
/* displays the largest of two numbers */
int larger(int x,int y); /* function prototype */
int
main() {
y=larger(num1,num2); /* calling function */ }
int larger(int x,int y) /* function definition */
return(larger_num);
Functions 12

32. Program Example 4
/* calculates the area and circumferencce of a circle */
float find_area(float r); /* function prototype */
float find_circum(float r); /* function prototype */
int
main() {
area = find_area(r); /* calling function */
circum = find_circum(r); /* calling function */ }
float find_area(float r) /* function definition */
{ return(PI*POW(r,2);}
float find_circum(float r)
{return(2.0*PI*r)}
Functions 13

33. Example 1
#include<iostream>
#include<cmath.h>
using namespace std;
double scale(double x, int n);
int main()
{ double num1;
int num2;
cout << "Enter a real number> ;
cin >> num1;
cout << “Enter an integer> ";
cin >> num2;
cout << "Result of call to function scale is \n", scale(num1,num2));
return 0; }
double scale(double x, int n) /* This function multiplies its first */
{ double scale_factor; /* argument by the power of */
scale_factor = pow(10,n); /* specified by its second argumnet */
return(x * scale_factor);
Functions 2

34. Example 2
#include<iostream>
# include<cmath>
using namespace std;
void print_comment();
double scale(double x, int n);
int main()
{ double num1,
int num2;
print_comment();
cout << "Enter a real number> ";
cin >> num1;
cout << "Enter an integer> ";
cin >> num2;
cout << "Result of call to function scale is \n",scale(num1,num2));
return 0; }
void print_comment(void)
{ cout << "The program will \n";}
double scale(double x, int n) { }
Functions 3

35. Example 3
include<iostream>
# include<cmath>
using namespace std;
double scale(double x, int n);
void display(double result);
int main()
{ double num1, result;
int num2;
cout << "Enter a real number> ";
cin >> num1;
cout << "Enter an integer> ";
cin >> num2;
result = scale(num1,num2);
display(result);
return 0;}
double scale(double x, int n)
{ }
void display(double result)
{ printf("Result of call to function scale is %.2f\n", result);}
Functions 4

36. Example 4
#include<iostream>
# include<cmath>
using namespace std;
double get_num1();
int get_num2();
double scale(double x, int n);
int main(void)
{ double num1,
int num2;
num1 = get_num1();
num2 = get_num2();
cout << "Result of call to function scale is\n",scale(num1,num2));
return 0;}
double get_num1(void)
{ double number1;
cout << "Enter a real number> ";
cin >> number1;
return(number1);}
int get_num2(void) {
return(number2); }
double scale(double x, int n) { }
Functions 5

37. Global and Local Declarations
When the declaration is placed at the start of the main function or
sub-functions.
Global Declaration
When the declaration is placed immediately after the pre-processor
directives.
IMPORTANT: in the C programming language local variables
have precedence over global variables.
Functions 2

38. Global and Local Declarations
#include <iostream>
/* global declarations */
void function1();
int main() {
/* local declarations */ }
void function1()
Functions 3

39. Example 1
#include<iostream>
using namespace std;
void function1();
int main()
{ int z; /* local declaration */
z = 5;
function1();
cout << “The value of z inside function main is ” << z);
return 0;}
void function1()
{ int z; /* local declaration */
cout << “The value of z inside functin1 is ” << z);}
The value of z inside function1 is
The value of z inside the function main is 5
Press any key to continue
Unknown
Functions 4

40. Example 2
#include<iostream>
using namespace std;
int z; /* global declaration */
void function1();
int main()
{ int z; /* local declaration */
z = 5;
function1();
cout << “The value of z inside function main is ” << z ;
return 0;}
void function1()
{ int z; /* local declaration */
cout << “The value of z inside functin1 is ” << z);}
The value of z inside function1 is
The value of z inside the function main is 5
Press any key to continue
Gives the same result as the
previous program since local declarations have precedence
over global declarations
Functions 5

41. Example 3
#include<iostram>
using namespace std;
int z; /* global declaration */
void function1();
int main()
{ int z; /* local declaration */
z = 5;
function1();
cout << “The value of z inside function main is \n” <<z);
return 0;}
void function1()
cout << “The value of z inside functin1 is \n” << z);}
The value of z inside function1 is 5
The value of z inside the function main is 5
Press any key to continue
Functions 6

42. Example 4
#include<iostream>
using namespace std;
int z = 2; /* global declaration */
void function1();
int main()
{ int z = 5; /* local declaration */
function1();
cout << “The value of z inside function main is \n” << z);
return 0;}
void function1()
{ int z; /* local declaration */
cout << “The value of z inside functin1 is \n” << z);}
The value of z inside function1 is 2
The value of z inside the function main is 5
Press any key to continue
Functions 7

43. Example 5
#include<iostream>
using namespace std;
int z; /* global declaration */
void function1();
void function2();
int main()
{ z = 5;
function1();
cout << “The value of z inside function main is \n”<<z);
function2();
cout << “The value of z inside function main is\n” << z);
return 0;}
void function1()
{ int z; /* local declaration */
z = 10;
cout << “The value of z inside functin1 is \n” << z);}
void function2()
{cout << “The value of z inside functin2 is \n”<< z);}
The value of z inside function1 is 10
The value of z inside the function main is 5
The value of z inside function2 is 5
Press any key to continue
Functions 8

44. Example 6
#include<iostream>
using namespace std;
int z; /* global declaration */
void function1();
void function2();
int main()
{ z = 15;
function1();
cout << “The value of z inside function main is \n” << z);
function2();
return 0;}
void function1()
{ int z; /* local declaration */
z = 11;
cout << “The value of z inside functin1 is \n” << z);}
void function2()
cout << “The value of z inside functin2 is \n” << z);}
The value of z inside function1 is 11
The value of z inside the function main is 15
The value of z inside function2 is
Press any key to continue
Unknown
Functions 9