FUNCTIONS

IN C PROGRAM
<p> COMSCI 1101 LECTURE </p>
TABLE OF CONTENTS.
01 02 03
Creating & Calling Passing Arguments
Overview of Functions
Functions to Functions

04 05 06
Call by Value & Call
Returning Values Types of Functions
by Reference
TABLE OF CONTENTS.
07 08
Scope of Function
Recursive Functions
Variables
OVERVIEW OF
FUNCTIONS
WHAT IS A FUNCTION?
▪ A function is a named, independent section of C
code that performs a specific task and optionally
returns a value to the calling statement.
WHAT IS A FUNCTION?
▪ A function is named. Each function has unique
identifier.

▪ By using that identifier in another part of the

program, you can execute the statements contained in
the function. This is known as calling the function.

▪ A function can be called from within another

function.
WHAT IS A FUNCTION?
▪ A function is independent. A function can perform
its task without interference from or interfering
with other parts of the program.

▪ A function performs a specific task. A task is a

discrete job that your program must perform as part
of its overall operation, like sending a line of
text to a printer.
WHAT IS A FUNCTION?
▪ A function can return a value to the calling
statement. When your statement calls a function, the
statements of a function contains are executed. If
you want them to, these statements can pass
information back to the calling program.
FUNCTIONS
▪ There are two types of function in C Programming

▪ Standard Library functions (built-in)

▪ User-defined functions (custom)

STANDARD LIBRARY
▪ The standard library functions are built-in
functions in C programming.

▪ These functions are defined in header files.

▪ The printf() and scanf() functions are defined in

the stdio.h header file.

▪ The sqrt() function is defined in the math.h header

file.
USER-DEFINED
▪ Functions that are created by the user are also
known as user-defined functions.

▪ We could create our own functions depending on

what we need in the program.
WHY USE FUNCTION?
▪ Function code is reusable.

▪ Functions make program smaller.

▪ Functions make program easier to write.

▪ Functions lead to improved commenting and

readability.

▪ Functions make program easier to maintain.

CREATING & CALLING
FUNCTIONS
FUNCTIONS
▪ Syntax:
[data_type] function_name([data_type param,…]){
data_type local_variable;
…
program_statement;
…
[return expression;]
}
FUNCTIONS
▪ The general format of a function is presented. The
first line of a function is called function
prototype declaration. It tells the compiler four
things about the function:

▪ Its data type

▪ Its name
▪ The argument it takes
▪ Who can call it
FUNCTIONS
▪ Like an operand and expression, a function also has
data type associated with it.

▪ The data type of a function is the data type of the

value it returns.

▪ If the data type is omitted, it defaults to int.

▪ Every function must have a name. Following the rules

of identifiers.
FUNCTIONS
▪ There can be only one function named main in a
program.

▪ Other functions may be named according to the rules

used in naming identifiers.

▪ Following the function’s name, enclosed in

parenthesis, is the list of arguments, along with
their data types, that are passed into the function.
FUNCTIONS
▪ Following the function prototype declaration is the
body of the function surrounded by curly braces.

▪ One of the statements it may contain is the return

statement (return is a C keyword).

▪ The expression following return is evaluated and its

value becomes the return value of the function.
#include <stdio.h>
#include <conio.h>

void print_message(){
printf(“Hello World!\n”);
}

void main(){
clrscr();

print_message();

getch();
}
Hello World!
_}
#include <stdio.h>
#include <conio.h>

int print_message(){
printf(“Hello World!\n”);
return 1;
}

void main(){
clrscr();
int a = 0;
a = print_message();
printf(“Returned value: %d\n”,a);
getch();
}
Hello World!
Returned value: 1
_}
PASSING ARGS
TO FUNCTIONS
#include <stdio.h>
#include <conio.h>

void double_it(float input, int number){

for(int i = 0; i < number; ++i){
input *= 2.0;
printf(“The result = %lf\n”,input);
}
}

void main(){
clrscr();

float data = 1.5;

double_it(data,3);

getch();
}
The result = 3.000000
The result = 6.000000
The result = 12.000000
_}
PASSING ARGUMENTS
▪ As seen, the function double_it accepts two
arguments.

▪ The value passed by the function call statement is

called arguments.

▪ The arguments passed into a function are known as

the function’s parameters.
PASSING ARGUMENTS
▪ Notice that the name of the variable data in the
main function is not the same name as its
corresponding parameter double_it.

▪ This is perfectly valid, as it is the variable’s

value that is being passed, not its name.
RETURNING
VALUES
RETURNING VALUES
▪ The C language provides a convenient mechanism
whereby the results of a function may be returned to
the calling routine. The syntax of this construct
is:

return expression;
RETURNING VALUES
▪ This statement indicates that the function is to
return the value of expression back to the calling
function.

▪ The function prototype declaration must reflect the

data type of the return value.

▪ The previous program examples did not return a

value. That is why the keyword void was used.
#include <stdio.h>
#include <conio.h>

float divide(int op1, int op2){

float result;
result = (float) op1 / op2;
return result;
}

void main(){
clrscr();

float answer;
answer = divide(3,2);
printf(“answer = %lf\n”,answer);

getch();
}
answer = 1.500000
_}
CALL BY VALUE &
CALL BY REFERENCE
CALL BY VALUE
▪ There are two ways to pass parameters to functions:

▪ They are known generically as “call by value” and

“call by reference”.

▪ In C, all arguments are passed “call by value”. This

means that each argument passed to a function is
evaluated, and its value is passed into the
function.
#include <stdio.h>
#include <conio.h>

void double_it(float input, int number){

for(int i = 0; i < number; ++i)
input *= 2.0;
printf(“double_it: the result = %lf\n”,input);
}

void main(){
clrscr();

float data = 1.5;

double_it(data,3);
printf(“main: data = %lf\n”,data);

getch();
}
double_it: the result = 12.000000
main: data = 1.500000
_}
CALL BY REFERENCE
▪ In a call by reference language, instead passing the
value of the argument into the function, a reference
to (i.e. the memory address of) the value is passed
into the function.

▪ This means that the function’s formal parameter

refers to the same memory location as the
corresponding variable in calling function.
#include <stdio.h>
#include <conio.h>

void double_it(float *input, int number){

for(int i = 0; i < number; ++i)
*input *= 2.0;
printf(“double_it: the result = %lf\n”,*input);
}

void main(){
clrscr();

float data = 1.5;

double_it(&data,3);
printf(“main: data = %lf\n”,data);

getch();
}
double_it: the result = 12.000000
main: data = 12.000000
_}
TYPES OF
FUNCTIONS
DIFFERENT FUNCTIONS
▪ We could create different kinds of user-defined
functions base on our needs:

▪ Non-returning functions without parameters

▪ Non-returning functions with parameters

▪ Returning functions without parameters

▪ Returning functions with parameters

NON-RETURNING FUNCTIONS
▪ Non-returning functions without parameters.

▪ Syntax:

void function_name(){
statement1;
statement2;
…
}
#include <stdio.h>
#include <conio.h>

void hello_world(){
printf(“Hello World!\n“);
}

void main(){
clrscr();

hello_world();

getch();
}
Hello World!
_}
NON-RETURNING FUNCTIONS
▪ Non-returning functions with parameters.

▪ Syntax:

void function_name(data_type param1,…){

statement1;
statement2;
…
}
#include <stdio.h>
#include <conio.h>

void hello_world(int x){

printf(“Hello World!\n“);
printf(“This is the value of param x: %d\n“,x);
}

void main(){
clrscr();

hello_world(1);

getch();
}
Hello World!
This is the value of param x: 1
_}
#include <stdio.h>
#include <conio.h>

void hello_world(int x, double y, char z){

printf(“Hello World!\n“);
printf(“This is the value of param x: %d\n“,x);
printf(“This is the value of param y: %lf\n“,y);
printf(“This is the value of param z: %c\n“,z);
}

void main(){
clrscr();

hello_world(1, 2.50, ’A’);

getch();
}
Hello World!
This is the value of param x: 1
This is the value of param y: 2.500000
This is the value of param z: A
_}
RETURNING FUNCTIONS
▪ Returning functions without parameters.

▪ Syntax:

data_type function_name(){
statement1;
statement2;
return expression;
}
#include <stdio.h>
#include <conio.h>

int getInteger(){
int value;
printf(“Enter an integer value: “);
scanf(“%d”,&value);
return value;
}
void main(){
clrscr();
int number;
number = getInteger();
printf(“The value of number is %d“,number);

getch();
}
Enter an integer value: 4
The value of number is 4
_}
RETURNING FUNCTIONS
▪ Returning functions with parameters.

▪ Syntax:

data_type function_name(data_type param1,…){

statement1;
statement2;
return expression;
}
#include <stdio.h>
#include <conio.h>

double computeAverage(double math, double science, double english){

double average;
average = (math + science + english) / 3;
return average;
}

void main(){
clrscr();
double mathGrade = 90, sciGrade = 85, engGrade = 98, result;

result = computeAverage(mathGrade, sciGrade, engGrade);

printf(“Average grade is %.2lf“,result);

getch();
}
Average grade is 91.00
_}
SCOPE OF FUNCTION
VARIABLES
#include <stdio.h>
#include <conio.h>

void main(){
clrscr();

int a = 1, b = 2, c = 3;
{
int a = 5, b = 6;
printf(“inner block a: %d\n”,a);
printf(“inner block b: %d\n”,b);
printf(“inner block c: %d\n”,c);
}
printf(“outer block a: %d\n”,a);
printf(“outer block b: %d\n”,b);
printf(“outer block b: %d\n”,c);
getch();
}
inner block a: 5
inner block b: 6
inner block c: 3
outer block a: 1
outer block b: 2
outer block c: 3
_}
FUNCTION VARIABLES
▪ An outer block variable name is valid in an inner
block unless block redefines it.

▪ If an existing variable name is redefined in an

inner block, or a new variable name is defined in
an inner block, the variable is valid only within
that block, and is “hidden” from outer block.
FUNCTION VARIABLES
▪ Function’s local variables can only be accessed
from within the function in which they are defined;
they can not be accessed by any other function
(even if another function uses the same variable
name).

▪ Thus the scope of a local variable is: the function

in which it is defined.
#include <stdio.h>
#include <conio.h>

void customFunct(){
int a = 4;
printf(“customFunct a: %d\n”,a);
}

void main(){
clrscr();

int a = 2;
printf(“main a: %d\n”,a);
customFunct();

getch();
}
main a: 2
customFunct a: 4
_}
FUNCTION VARIABLES
▪ As we know variables which are declared within the
bounds of a function or block are referred as local
variables or internal variables.

▪ The scope of internal variable is the function or

block in which they reside.
FUNCTION VARIABLES
▪ Variables may also be declared outside of any
function block, in the same source file.

▪ They are referred to as global variables or

external variables.

▪ A global variable can be accessed by any function

and is available to use throughout the entire
program.
#include <stdio.h>
#include <conio.h>

int a = 3;

void customFunct(){
printf(“customFunct a: %d\n”,a);
}

void main(){
clrscr();

printf(“main a: %d\n”,a);
customFunct();

getch();
}
main a: 3
customFunct a: 3
_
RECURSIVE
FUNCTIONS
RECURSIVE FUNCTIONS
▪ It is possible to call a function inside the same
function, this process is called recursion or
recursive call of a function.

▪ Using recursion, the code stays simpler and shorter

compared to an iterative statement (looping.)
#include <stdio.h>
#include <conio.h>

void getNumber(){
int num;
printf(“Enter a number: ”);
scanf(“%d”,&num);
if(num != 0)
getNumber();
}

void main(){
clrscr();
getNumber();
getch();
}
Enter a number: 2
Enter a number: 5
Enter a number: 1
Enter a number: 0
_
RECURSIVE FUNCTIONS
▪ By using recursion in returning functions, it is
necessary to use multiple return statements for
different outcomes.

▪ Be careful in using recursion, like iterative

statements you could write a program that never
terminates using recursion.
#include <stdio.h>
#include <conio.h>

int sumOf(int val){

if(val > 0)
return val + sumOf(val - 1);
else
return 0;
}

void main(){
clrscr();
int num = 5;
printf(“Result: %d\n“,sumOf(num));
getch();
}
Result: 15
_
THANK
YOU!