BCSE102L C PROGRAMMING
Structured LANGUAGE-
and MODULE-4
Object
Oriented By,
Dr. S. Vinila Jinny,
Programming ASP/SCOPE
SYLLABUS
INTRODUCTION
At times, during programming, there is a
need to store multiple logically related
elements under one roof.
For instance, an employee’s details like
name, employee number, and designation
need to be stored together.
In such cases, the C language provides
structures to do the job for us.
WHAT IS STRUCTURE?
The structure is a user-defined data type in C, which
is used to store a collection of different kinds of
data.
The structure is something similar to an array; the
only difference is array is used to store the same data
types.
struct keyword is used to declare the structure in C.
Variables inside the structure are called members of
the structure.
STRUCTURE DEFINITION
STRUCTURE EXPLANATION
A structure can be defined as a single entity
holding variables of different data
types that are logically related to each
other.
All the data members inside a structure are
accessible to the functions defined outside
the structure. To access the data members
in the main function, you need to create a
structure variable.
SYNTAX TO DEFINE A STRUCTURE IN C
struct structName
{
// structure definition
Data_type1 member_name1;
Data_type2 member_name2;
Data_type2 member_name2;
};
DESCRIPTION OF THE SYNTAX
Keyword struct: The keyword struct is used at the
beginning while defining a structure in C.
structName: This is the name of the structure which is
specified after the keyword struct.
data_Type: The data type indicates the type of the data
members of the structure. A structure can have data
members of different data types.
member_name: This is the name of the data member of
the structure. Any number of data members can be
defined inside a structure. Each data member is
allocated a separate space in the memory.
EXAMPLE
struct employee
{ int id;
char name[10];
float salary;
};
EXAMPLE-MEMORY REPRESENTATION
DECLARING STRUCTURE VARIABLE
We can declare a variable for the structure
so that we can access the member of the
structure easily.
There are two ways to declare structure
variable:
By struct keyword within main() function
By declaring a variable at the time of
defining the structure.
DECLARING STRUCTURE VARIABLE
1st way:
Let's see the example to declare the structure variable by
struct keyword. It should be declared within the main
function.
struct employee
{ int id;
char name[50];
float salary;
};
int main(){
struct employee e1, e2;
return 0; }
DECLARING STRUCTURE VARIABLE
2nd way:
Let's see another way to declare variable at the time of
defining the structure.
struct employee
{ int id;
char name[50];
float salary;
}e1,e2;
ACCESSING MEMBERS OF THE STRUCTURE
There are two ways to access structure
members:
By . (member or dot operator)
By -> (structure pointer operator)
EXAMPLE
#include<stdio.h>
#include <string.h>
struct employee
{ int id;
char name[50];
}e1;
int main( )
{
e1.id=101;
strcpy(e1.name, "Sonoo Jaiswal");
printf( "employee 1 id : %d\n", e1.id);
printf( "employee 1 name : %s\n", e1.name);
return 0;
}
employee 1 id : 101
employee 1 name : Sonoo Jaiswal
STRUCTURE POINTERS
Structure pointers are pointer variables that
holds the address of another variable.
Syntax:
struct structure_name *ptr;
To access members of structure using the
structure variable, we used the dot . operator.
But when we have a pointer of structure type, we
use arrow -> to access structure members.
STRUCTURE POINTERS
#include <stdio.h> int main()
{
struct my_structure struct my_structure variable = {“JACKIN", 35, 1};
{ struct my_structure *ptr;
char name[20]; ptr = &variable;
int number;
printf("NAME: %s\n", ptr->name);
int rank;
printf("NUMBER: %d\n", ptr->number);
};
printf("RANK: %d", ptr->rank);
return 0;
}
STRUCTURE ASSIGNMENT
Structure variables can be assigned to another structure variable
using assignment operator(=)
#include<stdio.h>
int main()
{
Struct sample
{
int a;
int b;
}x,y;
x.a=10;
x.b=200;
y=x; // direct assignment
printf(“%d %d”, y.a,y.b)
return 0;
}
ARRAY OF STRUCTURES
As normal varaiable, we can create array on
structure variable.
Syntax:
struct structure_name variable[array size];
void ask()
ARRAY OF {
STRUCTURES for(i = 0; i < 3; i++)
{
#include<stdio.h> printf("\nEnter %dst Employee
record:\n", i+1);
struct Employee
printf("\nEmployee name:\t");
{
scanf("%s", emp[i].ename);
char ename[10];
printf("\nEnter Salary:\t");
int sal; scanf("%d", &emp[i].sal);
}; }
struct Employee emp[5]; printf("\nDisplaying Employee record:\n");
int i, j; for(i = 0; i < 3; i++)
{
void main() printf("\nEmployee name is %s",
{ emp[i].ename);
ask(); printf("\nSlary is %d", emp[i].sal);
} }
}
PASSING STRUCTURES TO FUNCTIONS
#include<stdio.h> void show(struct Student st)
struct Student {
{ printf("\nstudent name is %s", st.name);
char name[10]; printf("\nroll is %d", st.roll);
int roll; }
};
void show(struct Student st);
void main()
{
struct Student std;
printf("\nEnter Student record:\n");
printf("\nStudent name:\t");
scanf("%s", std.name);
printf("\nEnter Student rollno.:\t");
scanf("%d", &std.roll);
show(std);
}
STRUCTURES WITHIN STRUCTURES
Nesting of structures, is also permitted in C language.
Nested structures means, that one structure has another
stucture as member variable.
struct complex
{
int imag;
float real;
};
struct number
{
struct complex comp;
int integers;
} nu;
nu.comp.imag = 11;
ARRAYS WITHIN STRUCTURES
A structure can have array as its member.
struct Student
{
int a[10][10];
float b;
}y;
POINTERS AND STRUCTURES
You may recall that the name of an array
stands for the address of its zero-th
element.
Also true for the names of arrays of structure
variables.
Consider the declaration:
struct stud {
int roll;
char dept_code[25];
float cgpa;
} class[100], *ptr ;
POINTERS AND STRUCTURES
The name class represents the address of the
zero-th element of the structure array.
ptr is a pointer to data objects of the type
struct stud.
The assignment
ptr = class ;
will assign the address of class[0] to ptr.
When the pointer ptr is incremented by one
(ptr++) :
The value of ptr is actually increased by
sizeof(stud).
It is made to point to the next record.
POINTERS AND STRUCTURES
Once
ptr points to a structure variable, the
members can be accessed as:
ptr –> roll ;
ptr –> dept_code ;
ptr –> cgpa ;
The symbol “–>” is called the arrow operator.
WARNING
When using structure pointers, we should take
care of operator precedence.
Member operator “.” has higher precedence than “*”.
ptr –> roll and (*ptr).roll mean the same thing.
*ptr.roll will lead to error.
The operator “–>” enjoys the highest priority among
operators.
++ptr –> roll will increment roll, not ptr.
(++ptr) –> roll will do the intended thing.
EXAMPLE: COMPLEX NUMBER ADDITION
void main()
{
struct complex
{
float real;
float cmplex;
} a, b, c;
scanf (“%f %f”, &a.real, &a.cmplex);
scanf (“%f %f”, &b.real, &b.cmplex);
c.real = a.real + b.real;
c.cmplex = a.cmplex + b.cmplex;
printf (“\n %f + %f j”, c.real, c.cmplex);
}
DEFINING DATA TYPE: USING
TYPEDEF
One may define a structure data-type with a single
name
typedef struct newtype {
member-variable1;
member-variable2;
.
member-variableN;
} mytype;
mytype is the name of the new data-type
Also called an alias for struct newtype
Writing the tag name newtype is optional, can be
skipped
Naming follows rules of variable naming
29
TYPEDEF : AN EXAMPLE
typedef struct {
float real;
float imag;
} _COMPLEX;
Defineda new data type named _COMPLEX.
Now can declare and use variables of this type
_COMPLEX a, b, c;
30
TYPEDEF : AN EXAMPLE
typedef struct{
float real;
float imag;
} _COMPLEX;
void swap (_COMPLEX a, _COMPLEX b)
{
_COMPLEX tmp;
tmp = a;
a = b;
b = tmp;
}
TYPEDEF : AN EXAMPLE
void print (_COMPLEX a)
{
printf("(%f, %f) \n",a.real,a.imag);
}
void main()
{
_COMPLEX x={4.0,5.0}, y={10.0,15.0};
print(x); print(y);
swap(x,y);
print(x); print(y);
}
swap.c
TYPEDEF : AN EXAMPLE
Note: typedef is not restricted to just
structures, can define new types from any
existing type
Example:
typedef int INTEGER
Defines a new type named INTEGER from the
known type int
Can now define variables of type INTEGER which
will have all properties of the int type
INTEGER a, b, c;
STRUCTURES AND FUNCTIONS
A structure can be passed as argument to a
function
A function can also return a structure
EXAMPLE: COMPLEX NUMBER
ADDITION
void main()
{
_COMPLEX a, b, c;
scanf(“%f %f”, &a.real, &a.imag);
scanf(“%f %f”, &b.real, &b.imag);
c = add (a, b) ;
printf(“\n %f %f”, c,real, c.imag);
}
_COMPLEX add(_COMPLEX x, _COMPLEX
y)
{
_COMPLEX t;
t.real = x.real + y.real;
t.imag = x.imag + y.imag ;
return (t) ;
} 35
EXERCISE PROBLEMS
1. Extend the complex number program to include
functions for addition, subtraction, multiplication, and
division
2. Define a structure for representing a point in two-
dimensional Cartesian co-ordinate system
• Write a function to compute the distance between
two given points
• Write a function to compute the middle point of the
line segment joining two given points
• Write a function to compute the area of a triangle,
given the co-ordinates of its three vertices
