Functions

10

Introduction to Programming
 Top-Down Design

• Also called “Divide and Conquer”

• A problem solving method in which you

first break a problem up into its major
sub-problems to derive a solution to the
original problem.

Introduction to Programming
 Functions in C

• Execution starts and ends with the

main function

• This function can call other functions to

do special tasks
• Ex. Calling printf and scanf functions

Introduction to Programming
 Functions in C

• Purpose: to receive 0 or more pieces of

data, operate on them, and return at
most one piece of data.

input function output

Introduction to Programming
 Why use function subprograms?
• Top-Down Design
– easier and simpler
– Subprograms make it easier to divide
programming tasks

• Reuse of Code
– Functions can be executed more than
once
– Easier to alter code

Introduction to Programming
 Why use function subprograms?
• Procedural abstraction
– Procedures – functions in C
– A programming technique in which
we use function sub-programs to
allow us to remove from the main
function the code that provides
detailed solution to a sub-problem

Introduction to Programming
 Why use function subprograms?
• Protection of Data
– Centers around the concept of
local data – data available only to the
function wherein it is declared and only
when the function is executing
Note:
When the function is done, data is gone

Introduction to Programming
 Function Declaration

• Done with a function prototype

statement
• Placed after the preprocessor directives
and before the main function
• Syntax:
return_type function_name (formal parameter list);

Introduction to Programming
 Function Definition

• Contains the code for the detailed

solution to complete a function’s task
• Syntax

return_type function_name (formal parameter list)

{
/* local declarations */
/* executable statements */
}

Introduction to Programming
 Function Header

• Formal parameter list – a list that

declares the variables that will contain
the data received by the function
• Void – used if there are no parameters
• You may omit the void and write it as ()

Introduction to Programming
 Function Body

• Contains the local variable declarations

and executable statements for the
function
• It may or not have a return statement
(omitted in void functions)

Introduction to Programming
 Function Call

• Using the function

• Syntax
function_name (actual parameter list)
Formal parameters – variables that are
declared in the function header.
Actual parameters – expressions in the
function call

Introduction to Programming
 Function Call

• Void functions
– functions that don’t return a value
– Cannot be part of an expression
– Can only be used as a stand-alone
statement
• All other functions return a value
– Can be used either a part of an
expression or a stand-alone statement

Introduction to Programming
#include <stdio.h>

void prn_message(void);

int main()
{
prn_message();
return 0;
}

void prn_message(void)
{
printf("\nMessage for you: ");
printf("Have a nice day! \n");
}

Introduction to Programming
#include <stdio.h>

void prn_message(int k)
{
int i;

printf("Message for you:\n");

for(i=0; i<k; ++i)
printf(" Have a nice day!\n);
}

int main()
{
int n;
printf("Input a small positive integer: ");
scanf("%d",&n);
prn_message(n);

return 0;
}

Introduction to Programming
 The Rules

• A function may accept as many

parameters as it needs, or no
parameters
• A function may return either one or no
values
• Variable declared inside a function are
only available to that function, unless
explicitly passed to another function

Introduction to Programming
 Writing a Function - Example
int print_table(double start, double end,
double step)
{
double d;
int lines = 1;
printf(“Celcius\tFarenheit\n”);
for(d =start; d <=end; d+=step, lines++)
printf(“%.1lf\t%.1lf\n”,d, d*1.8+32);
return lines;
}

Introduction to Programming
 Writing a Function - Example
#include <stdio.h>
int print_table(double, double, double);
int main()
{
int how_many;
double end = 100.0;

how_many = print_table(1.0, end, 3);

print_table(end, 200, 15);
return 0;
}
Introduction to Programming
 Passing of Parameters

• Call by value
– Transfers only the value
– Any changes made will not be
reflected after the function terminates
• Call by reference
– Pointer to the actual parameter
– Any changes made will remain after
the function terminates

Introduction to Programming
 Scope

• Refers to the region of a program where

a particular meaning of a name
(identifier) is visible or can be
referenced.
• It pertains to any identifier or object
that can be defined, such as a variable
or a function prototype statement.

Introduction to Programming
 Scope

2 Concepts to consider
• Block- one or more statements
enclosed in a set of curly brackets
• Global area – consists of statements
that are outside the functions
Note: an object’s scope extends from where it is
declared until the end of its block or functions.

Introduction to Programming
 Scope
• The following code will NOT compile:
#include <stdio.h>

int main()
{
{
int seventy_eight = 78;
printf("seventy_eight = %d", seventy_eight);
}

printf("\nseventy_eight = %d\n", seventy_eight);

}

• Not because there are braces but because

seventy_eight's declaration is not visible
outside the inner block
Introduction to Programming
 Scope

• Global scope – any object defined in

the global area of a program is visible
from its definition/declaration until the
end of the program
• Local scope – any object defined within
a block and is visible from the point of
declaration until the end of the block.
Outside the block they are not visible.

Introduction to Programming
 Scope Rules
• 1. An identifier may only be used within the
function in which it is declared.
– The same identifier may be reused on a
different block or scope.
– Declaring two variables with the same identifier
within the same block is prohibited
• 2. In case that when an identifier is declared more
than once within the same program, an identifier
reference always refers to the definition in the
inner most block defining the identifier.

Introduction to Programming
 Variables

• Global variables – variables that may

be used all throughout the program

• Local variables – variables defined

within the function, available only
during function execution.

Introduction to Programming
 Scope Rules
#include <stdio.h>

int num1 = 5; /*Global variable*/

int main()
{
/* Local variables*/
int num1 = 3, num2 = 4;
Output:
if (num1 < num2){
int num2 = 1; /*num2 redeclared*/ Labas!
Outside num2 = 4;
if(num1 < num2) {
printf("Pasok!\n");
}

else printf("Labas!\n");
}

printf("Outside num2 = %d\n",num2);

Introduction to Programming
}
 Scope Rules
• The following code will NOT compile:
#include <stdio.h>

int main()
{
int num1 = 3, num2 = 4;
int num2 = 1; /*num2 redeclared*/

if (num1 < num2){

if(num1 < num2) {
printf("Pasok!\n");
}

else printf("Labas!\n");
}

printf("Outside num2 = %d\n",num2);

}
Introduction to Programming
 Standard Mathematical
Functions
• As an example of calculation, consider
the calculation of the roots of a
quadratic equation: ax2 + bx + c = 0
• We can use the square root function of
C sqrt() defined in math.h
• To use this function, the include
statement must appear at the head of
the program:
#include<math.h>

Introduction to Programming
 Standard Mathematical
Functions
...
float a, b, c;
float d, r1, r2;
printf(“Enter 3 numbers: “);
scanf(“%f %f %f”, &a, &b, &c);

d = (b*b) – (4.0 * a * c);

r1 = (-b + sqrt(d))/(2.0 * a);
r2 = (-b - sqrt(d))/(2.0 * a);
... Introduction to Programming
 Example: Roots of a Quadratic

• We first check if both roots are non-imaginary

by finding the discriminant

...
d = (b*b) – (4.0 * a * c);
if(d< 0)
printf(“Imaginary roots”);
else{
r1 = (-b + sqrt(d))/(2.0 * a);
r2 = (-b - sqrt(d))/(2.0 * a);
printf(“%f %f”,r1,r2);
}
... Introduction to Programming
 Standard Mathematical
Functions
cos(x) Cosine of the angle x, expressed in
radians
sin(x) Sine of the angle x, expressed in
radians
tan(x) tangent of the angle x, expressed in
radians
abs(x) The absolute value of x, sometimes
written as |x|
log(x) Natural logarithm of x ( to the base e)

pow(x,y) x raised to the power of y

Introduction to Programming