arrays.ppt

Course Name: Fundamentals of Computing
Course Code: CS16
Credits: 2:0:0
UNIT 4
Term: January-March 2021
M.S. Ramaiah Institute of Technology
(Autonomous Institute, Affiliated to VTU)
Department of Computer Science and Engineering

User Defined Functions:
 Introduction,
Need for User-Defined Functions,
 Elements of User-Defined Functions,
 Definition of Functions,
Return Values and Their Types, Function Calls,
Categories of Functions,
 Recursion.

•A function is a block of code that performs a specific task.
•A large C program is divided into basic building blocks called C function. C function contains set
of instructions enclosed by “{ }” which performs specific operation in a C program.
•There are many situations where we might need to write same line of code for more than once in a
program. This may lead to unnecessary repetition of code, bugs and even becomes boring for the
programmer. So, C language provides an approach in which you can declare and define a group of
statements once in the form of a function and it can be called and used whenever required.
•C allows you to define functions according to your need, These functions are known as user-
defined functions.

C functions can be classified into two categories:
•Library functions
•User-defined functions
•Library functions are those functions which are already defined in C library,
example printf(), scanf(), strcat() etc. You just need to include appropriate header files to use these
functions. These are already declared and defined in C libraries.
•A User-defined functions on the other hand, are those functions which are defined by the user at
the time of writing program. These functions are made for code reusability and for saving time and
space.

Benefits/Need of Using Functions:
•It provides modularity to your program's structure.
•A large C program can easily be tracked when it is divided into functions.
•It makes your code reusable. You just have to call the function by its name to use it, wherever
required.
•In case of large programs with thousands of code lines, debugging and editing becomes easier if
you use functions.
•It makes the program more readable and easy to understand.
•It is used to avoid rewriting same logic/code again and again in a program.

There are a few steps that need to be follow in order to create a function:
Function Declaration: Like variable declaration, a function declaration specifies the type of the
function.
Function Definition: A function needs to be defined in order to be used. It is the actual function that
we are going to work on.
Function parameters: They contain values or arguments that are sent by the calling function.
Function call: It is how we are going to call the function to get executed.

A function declaration specifies:
•The type of the function or return type,
•The function name and
•Its parameters.
•Function return type: It indicates what type of value the function will return. Eg: int, double, float, char, etc.
A function with void return type does not return any value.
•Function name: A function name can be anything the user decides. Usually, a function name is kept
according to the function it performs.
•Function Parameter: It contains arguments and may or may not take values from the calling function.
Function Declaration:
return_type function_name(parameters);
•It is usually done at the top of the
program and indicates how the function
shall be called.
• The actual function definition can be
present anywhere in the program.

Function Definition
return_type function_name(parameter)
{
//body of the function
}
•The first line is known as function header
•returntype functionName(type1 parameter1, type2 parameter2)
•The Second line is function body
It contains the declarations and the statements(algorithm) necessary for performing
the required task. The body is enclosed within curly braces { ... } and consists of
three parts.
•local variable declaration(if required).
•function statements to perform the task inside the function.
•a return statement to return the result evaluated by the function(if return type
is void, then no return statement is required).
Elements of User-Defined Functions:
1. Function name
2. Function Return Type
3. List of parameters
4. Local variables
5. C Function statements
6. Return Statement

There are two types of function parameters/Arguments:
•Formal Parameter: The parameter which is written at the function definition is known as a formal
parameter.
•Actual Parameter: The parameter that is written at the function call is known as the actual parameter.
int sum(int,int); Function Declaration/ Function Prototype
void main()
{
int a ,b ;
sum(a ,b );//actual parameter Calling Function (Function Call)
}
int sum(int x, int y)//formal parameter Called Function(Function
Definition )
{
//body of the function
}
Return Values and Their Types, Function Calls

Return Type:
•When a function is declared to perform some sort of calculation or any operation and is expected to
provide with some result at the end, in such cases, a return statement is added at the end of function body.
•Return type specifies the type of value(int, float, char, double) that function is expected to return to
the program which called the function.
•Note: In case your function doesn't return any value, the return type would be void.
Returning a value from function:
•A function may or may not return a result. But if it does, we must use the return statement to output the
result. return statement also ends the function execution, hence it must be the last statement of any
function. If you write any statement after the return statement, it won't be executed.

A function needs to be called by the calling function in order to get executed. There are two ways in which a
function can be called:
Call by reference: In this method, the address of the parameter or argument is put in the formal
parameter and then the values are accessed using the address in the actual parameter. Call by reference is
done as follows:
int sum(int *x,*y)// *x is the address which points to the value of the variable x stored in the address.
Call by value: In this method, the actual values are passed as an argument in the formal parameter and are
accessed in the actual parameter.
int sum(int x,int y) // x is the variable which contains the value so the value is directly passed to the
function
Note:- The difference between the above two is that, when we pass by reference then no new copy of the value is created i.e. the passed
variable is used and even if we do not return anything from the called function then also the changes will reflect inside the calling
function.
Function Call

Passing Arguments to a function Returning a value from function

Categories of Functions
There can be 4 different types of user-defined functions, they are:
•Function with no arguments and no return value
•Function with no arguments and a return value
•Function with arguments and no return value
•Function with arguments and a return value

1. With arguments
and with return values
function declaration:
int function ( int );
function call:
function ( a ); Function with argument
function definition:
int function( int a )
{
statements;
return a; Function with return value
}

2. With arguments and
Without return values
void function ( int );
function call:
function( a ); Function with argument
void function( int a )
{
statements; Function without return value
}

3. Without arguments and
without return values
void function();
function call:
function(); Function without argument
void function()
{
statements; Function without return value
}

4. Without arguments and
With return values
int function ( );
function call:
function ( ); Function without argument
int function( )
{
statements;
return a; Function with return value
}

What is Recursion?
Recursion is a special way of
nesting functions, where a
function calls itself inside
it.
We must have certain
conditions in the function to
break out of the recursion,
otherwise recursion will
occur infinite times.
#include<stdio.h>
int factorial(int x); //declaring the function
void main()
{
int a, b;
printf("Enter a number...");
scanf("%d", &a);
b = factorial(a); //calling the function named factorial
printf("%d", b);
}
int factorial(int x) //defining the function
{
int r = 1;
if(x == 1)
return 1;
else
r = x*factorial(x-1); //recursion, since the function calls itself
return r;
}

The scope, visibility and lifetime of variables:
• Automatic variables,
•Static Variables,
•Register Variables, and
•External Variables.

•Scope is defined as the area in which the declared variable is ‘available’.
•The lifetime of a variable is the period of time in which the variable is allocated a space (i.e., the
period of time for which it “lives”).
•Visibility is the “accessibility” of the variable declared.
The scope of a variable is the part of the program within which the variable can be used. So, the
scope describes the visibility of an identifier within the program.
The lifetime of a variable or function is the time duration for which memory is allocated to store it, and
when that memory is released. It also refered as extent of a variable.

There are two basic types of scope: local scope and global scope.
•A variable declared outside all functions is located into the global scope.
•Access to such variables can be done from anywhere in the program.
•These variables are located in the global pool of memory, so their lifetime coincides with the lifetime
of the program.
•A variable declared inside a block (part of code enclosed in curly brackets) belongs to the local
scope.
•Such a variable is not visible (and therefore not available) outside the block, in which it is declared.
•The most common case of local declaration is a variable declared within a function. A variable
declared locally, is located on the stack, and the lifetime of such a variable is equal to the lifetime of
the function.

Register variables: belong to the register storage class and are stored in the CPU registers.
The scope of the register variables is local to the block in which the variables are defined.
The variables which are used for more number of times in a program are declared as register
variables for faster access.
Example: loop counter variables.
register int y=6;
Static variables: Memory is allocated at the beginning of the program execution and it is reallocated
only after the program terminates. The scope of the static variables is local to the block in which the
variables are defined.

#include<stdio.h>
int number; // global variable
void main()
{
number = 10;
printf("I am in main function. My value is %dn", number);
fun1();
fun2();
}
/* This is function 1 */
fun2()
{
printf("nI am in function fun2.
My value is %d", number);
}
/* This is function 1 */
fun1()
{
number = 20; // local variable
printf("I am in function fun1.
My value is %d", number);
}
I am in function main. My value is 10
I am in function fun1. My value is 20
I am in function fun2. My value is 20

#include <stdio.h>
void decrement() Function Definition
{
static int a=5;
a--;
printf("Value of a:%dn", a);
}
int main()
{
int i , n=4;
for(i=0; i<n; i++)
decrement(); Function Call
return 0;
}
Example for Static variable
Value of a:4
Value of a:3
Value of a:2
Value of a:1
#include <stdio.h>
void decrement()
{
int a=5;
a--;
printf("Value of a:%dn", a);
}
int main()
{
int i , n=4;
for(i=0; i<n; i++)
decrement();
return 0;
} Value of a:4
Value of a:4
Value of a:4
Value of a:4
With Static variable Without Static storage class

#include<stdio.h>
void test(); //Function declaration
int main()
{
test();
test();
test();
}
void test()
{
static int a = 0;
a = a + 1;
printf("%dt",a);
}
OUTPUT: 1 2 3
#include<stdio.h>
void test(); //Function declaration
int main()
{
test();
test();
test();
}
void test()
{
int a = 0;
a = a + 1;
printf("%dt",a);
}
With Static variable Without Static storage class

What is a Storage Class?
•A storage class represents the visibility and a location of a variable. It tells from what part of code we can
access a variable.
•There are total four types of standard storage classes. The table below represents the storage classes in 'C'.

The variables defined using auto storage class are called as local variables.
• Auto stands for automatic storage class. A variable is in auto storage class by default if it is not
explicitly specified.
•The scope of an auto variable is limited with the particular block only.
#include <stdio.h>
int main( )
{
auto int j = 1;
{
auto int j= 2;
{
auto int j = 3;
printf ( " %d ", j);
}
printf ( "t %d ",j);
}
printf( "%dn", j);
}
OUTPUT: 3 2 1
#include <stdio.h>
int main( )
{
int j = 1;
{
int j= 2;
{
int j = 3;
printf ( " %d ", j);
}
printf ( "t %d ",j);
}
printf( "%dn", j);
}
OUTPUT: 3 2 1

Extern storage class is used when we have global functions or variables which are shared between two or
more files.
Keyword extern is used to declaring a global variable or function in another file to provide the reference
of variable or function which have been already defined in the original file.

C storage class is used to define the scope variables and function. There
are four various types of storage classes that are given below.

Table summarizes the principal features of each storage class which are commonly used in C programming

Structures:
• Defining a Structure,
•Declaring Structure Variables,
• Accessing Structure Members,
•Structure Initialization,
•Copying and Comparing Structure variables,
•Arrays of Structures,
•Arrays within Structures.

Structure is a user-defined data type in C programming language ,that combines logically related data
items of different data types together.
•Arrays allow to define type of variables that can hold several data items of the same kind.
Similarly structure is another user defined data type available in C that allows to combine data items
of different kinds.
•struct keyword is used to declare the structure in C.
•Variables inside the structure are called members of the structure.
struct struct_name
{
DataType member1_name;
DataType member2_name; DataType
member3_name;
…
};
struct employee
{
char name[50];
int age;
float salary;
};
Syntax: Examples:
Defining a Structure
struct student
{
char name[60];
int roll_no;
float marks;
}

Declaring Structure Variables
struct student
{
char name[60];
int roll_no;
float marks;
} s1,s2,s3….sn;
members of the structure
Name of the structure
Declaring Structure variables
s1,s2,s3….sn
at the time of definition
void main()
{
struct student s1,s2,s3........sn; // Declaring Structure variables
within a main function.
}
#include <stdio.h>
struct student
{
char name[60];
int roll_no;
float marks;
};
Defining a structure called “ student ” before the main function
Example1 :
Example 2:

Accessing Structure Members
How to access data members of a structure using a struct variable?
Using Dot(.) operator
#include <stdio.h>
struct student
{
char name[60];
int roll_no;
float marks;
} s1;
#include<stdio.h>
struct Point
{
int x, y;
};
int main()
{
struct Point p1 = {0, 1};
// Accessing members of point p1
p1.x = 20;
P2.y=10;
printf ("x = %d, y = %d", p1.x, p1.y);
return 0;
/*Assigning the values of each struct member here*/
s1. name = “ramesh”;
s1. roll_no = 101;
s1. marks = 25.0
Example 2:
Example1 :

#include <stdio.h>
struct student
{
char name[60];
int roll_no;
float marks;
} s1;
int main()
{
printf("Enter the following information:n");
printf("Enter student name: ");
scanf( “%s”, s1.name)
printf("Enter student roll number: ");
scanf("%d", & s1. roll_no);
printf("Enter students marks: ");
scanf("%f", & s1.marks);
printf("The information you have entered is: n");
printf("Student name: %s n” , s1.name);
printf("Student roll number: %d n", s1. roll_no);
printf("Student marks: %f n", s1.marks);
return 0;
}

Structure Initialization
#include<stdio.h>
struct Point
{
int x, y, z;
};
int main()
{
// Examples of initialization
struct Point p1 = {10,20,30};
struct Point p2 = {20,40,60,60};
printf ("x = %d, y = %d, z = %dn", p1.x, p1.y, p1.z);
printf ("x = %d, y = %d, z = %dn", p2.x, p2.y, p2.z);
return 0;
}
Structure member initialization
Example1 :

#include <stdio.h>
struct student
{
char name[60];
int roll_no;
float marks;
} s3={ “pavan”, 103, 25};
int main()
{
struct student s1 = { “ramesh”, 101, 23 };
struct student s2 = { “suresh”, 102, 27 };
printf ("x = %s, y = %d, z = %fn", s1.name, s1.roll_no, s1.marks);
printf ("x = %s, y = %d, z = %fn", s2.name, s2.roll_no, s2.marks);
}
Structure member (S1 and S2)
initialization
Example 2:
Structure member (S3) initialization

Copying and Comparing Structure variables
main()
{
int x;
struct class student1 = {111,"Ramesh",72.50};
struct class student2 = {222,"Reddy", 67.00};
struct class student3;
struct class
{
int number;
char name[20];
float marks;
};
student3 = student2; Copying Structure variables
x =((student3.number == student2.number) && (student3.marks == student2.marks)) ? 1 : 0;
if(x == 1) Comparing Structure variables
{
printf(“student2 and student3 are samen", student3.number, student3.name, student3.marks);
}
else
{
printf("nstudent2 and student3 are differentnn");
}
}
Structure Definition
Structure Declaration and Initialization

Arrays of Structures
/* Array of Structures in C Initialization */
struct Employee
{
int age;
char name[10];
int salary;
} Employees[4] = { {25, "Suresh", 25000}, {24, "Tutorial", 28000}, {22, "Gateway", 35000}, {27, "Mike", 20000} };
Employees[0] ={25, "Suresh", 25000}; Employees[1] =
{24, "Tutorial", 28000}; Employees[2] = {22, "Gateway",
35000}; Employees[3] = {27, "Mike", 20000};
Example 1:

struct student
{
int age;
char name[10];
int marks;
};
void main()
{
struct student S[4];
S[4] = { {25, "Suresh", 25},
{24, “Ramesh", 28},
{22, “Anoop", 35},
{27, “Arun", 20}
};
}
Arrays of Structures
Initialization members
Example 2:

int main()
{
int i;
struct student record[2];
// 1st student's record
record[0].id=1;
strcpy(record[0].name, "Raju");
record[0].percentage = 86.5;
// 2nd student's record
record[1].id=2;
strcpy(record[1].name, "Surendren");
// 3rd student's record
record[2].id=3;
strcpy(record[2].name, "Thiyagu");
}
struct student
{
int id;
char name[30];
float percentage;
};
for(i=0; i<3; i++)
{
printf(" Records of STUDENT : %d n", i+1);
printf(" Id is: %d n", record[i].id);
printf(" Name is: %s n", record[i].name);
printf(" Percentage is: %fnn",record[i].percentage);
}
return 0;
}
Array of Structure, Declaration
Printing of Members
Initialization of members

Thank you
42
DEPARTMENT OF COMPUTER SCIENCE AND ENGINEERING

arrays.ppt

More Related Content

Similar to arrays.ppt (20)

Recently uploaded (20)

arrays.ppt