UNIT-III
Structures
53. A structure is a collection of one or
more variables, possibly of different data types, grouped together under a
single name for convenient handling. A structure is a convenient way of
grouping several pieces of related information together.
Structure is user defined data type which is
used to store heterogeneous data under unique name. Keyword 'struct' is used to
declare structure.
The variables which are declared
inside the structure are called as 'members of structure'.
54.
Syntax of structure definition:
struct tag_name
{
data_type member_1;
data_type member_2;
data_type member_n;
};
55.
Defining a Structure(using typedef)
typedef defines and names a new type,
allowing its use throughout the program. typedefs usually occur just after the
#define and #include statements in a file.
Example structure definition.
typedef struct
{
char name[64];
char course[128];
int age;
int year;
} student;
This defines a new type student
variables of type student
56.
Declaring Stucture Variables:
The first way is to declare a
structure followed by structure definition like this :
struct structure_name
{
structure _member;
.....
}instance_1,instance_2,..instance_n;
In the second way, we can declare the
structure instance at a different location in our source code after structure
definition(in the main function).
Here is structure declaration syntax
:
struct struct_name
instance_1,instance_2 instance_n;
Example: struct student s;
57.
Accessing Members of a Structure
Each member of a structure can be
used just like a normal variable, but its name will be a bit longer. In the
above, member name of structure „s‟ will behave just like a normal array
of char, however we refer to it by the name
s.name
Here the dot is an operator which
selects a member from a structure(member operator). Where we have a pointer to
a structure we could dereference the pointer and then use dot as a member
selector. This method is a little clumsy to type. Since selecting a member from
a structure pointer happens frequently, it has its own operator -> which
acts as follows. Assume that st_ptr is a pointer to a structure of type
student, We would refer to the name member as
st_ptr -> name
58.
Structures and functions
A structure can be passed as a
function argument just like any other variable. This raises a few practical
issues.
A structure can be passed to a
function in 3 ways.
(i) Passing
individual members of the structure to a function.
(ii) Passing a
copy of the structure variable( Call by value).
(iii) Passing a structure by passing
its pointer to the structure.
59.
Nested structures(Structures within
Structures) :
Structures can be used as structures
within structures. It is also called as 'nesting of structures'.
Syntax:
struct structure_nm
{
<data-type> element 1;
<data-type> element 2;
- - - - - - - - - - -
- - - - - - - - - - -
<data-type> element n;
struct structure_nm
{
<data-type> element 1;
<data-type> element 2;
- - - - - - - - - - -
- - - - - - - - - - -
<data-type> element n;
}inner_struct_var;
}outer_struct_var;
60.
Arrays within Structures:
Sometimes, it is necessary to use
structure members with array.
Program :
#include <stdio.h>
#include <conio.h>
struct result
{
int rno, mrks[5];
char nm;
}res;
61.
Arrays of structures:
An array of structures for the
example is declared in the usual way: 100 books
struct book
{
char name[20];
char author[20];
int pages;
float price;
} struct student[100];
62.Self referential Structures
A structure can contain a pointer to
another structure of its own type, or even to itself. This is because a pointer
to a structure is not itself a structure, but merely a variable that holds the
address of a structure. Pointers to structures are quite invaluable, in fact, for
building data structures such as linked lists and trees.
A pointer to a structure type
variable is declared by a statement such as the following:
struct student *st_ptr;
63.
Applications of Structures
1. Complex numbers in mathematics
2. structures could be used to hold the
locations of points in multi-dimensional space
3. Apart from holding data, structures
can be used as members of other structures. Arrays of structures are possible,
and are a good way of storing lists of data with regular fields, such as databases.
4. Another possibility is a structure
whose fields include pointers to its own type. These can be used to build
chains (programmers call these linked lists), trees or other connected
structures.
UNIONS
64.
Union is user defined data type used
to stored data under unique variable name at single memory location. Union is
similar to that of structure. Syntax of union is similar to structure.
To declare union data type, 'union'
keyword is used.
Union holds value for one data type
which requires larger storage among their members.
Syntax:
union union_name
{
<data-type> element 1;
<data-type> element 2;
<data-type> element 3;
}union_variable;
65.
major difference between structure
and union is 'storage.' In structures, each member has its own storage
location, whereas all the members of union use the same location. Union
contains many members of different types, it can handle only one member at a
time.
66. 
67. 
68.
Enumerations
An enumeration is a data type
consisting of a set of named values that represent integral constants, known as
enumeration constants.
An enumeration also referred to as an
enumerated type because we must list (enumerate) each of the values in
creating a name for each of them. In addition to providing a way of defining
and grouping sets of integral constants, enumerations are useful for variables
that have a small number of possible values.
ENUM is closely related to the
#define preprocessor.
It allows you to define a list of
aliases which represent integer numbers. For example if you find yourself
coding something like:
#define MON 1
#define TUE 2
#define WED 3
You could use enum as below.
enum week { Mon=1, Tue, Wed, Thu, Fri
Sat, Sun} days;
or
enum escapes { BELL = '\a', BACKSPACE
= '\b', HTAB = '\t',
RETURN = '\r', NEWLINE = '\n', VTAB =
'\v' };
or
enum boolean { FALSE = 0, TRUE };
An advantage of enum over #define is
that it has scope This means that the variable (just like any other) is only visable
within the block it was declared within.
We can declare an enumeration type
separately from the definition of variables of that type.We can define an
enumeration data type and all variables that have that type in one statement
69.
Bit Fields
In addition to declarators for
members of a structure or union, a structure declarator can also be a specified
number of bits, called a "bit field." Its length is set off from the
declarator for the field name by a colon. A bit field is interpreted as an integral
type.
Bit Fields allow the packing of data in a
structure
FILE MANAGEMENT IN C
70.
A file is nothing but a place on the
disk where a group of related data is stored. Until here we read and write data
through console I/o functions scanf and printf,
which always use the keyboard /screen as the target place.
71
The basic file operation in ‘C’
Ø Naming a file
Ø Opening a file
Ø Reading data from a file
Ø Writing data to a file
Ø Closing
file
72
File handling functions in ‘C’
library
fopen( ) → creates a new life for
use/open existing file
fclose( ) → closes file
getc( ) → read a char from file
putc( ) →writes a char to file
fprintf →writes a set of data values
to a file
fscanf → reads a se of data values
from a file
getw( ) → reads an integer from a
file
putw( ) → writes an integer to a file
fseek( ) → sets the position to a
designed point in file
ftell( ) → sets the position to the
beginning of file
73
Text files
Text files store character data. A
text file can be thought of as a stream of characters that can be processed
sequentially
74
Binary files
As far as the operating system is
concerned, a binary file is no different to a text file. It is a collection of
bytes.
75.
Mode for opening a file
r →opens file for reading only
w → opens file for writing only
a → opens file for appending
(adding)data.
r+ → for both reading and writing at
the beginning only
w+ → after writing we may read the
file without closing and reopening
a+ → open a file in read and append
mode
ð When the mode is writing new
file is created (or) the contents are deleted, if the file is already existed.
ð When the mode is appending,
the file is opened and add the contents of new (or) new file also created, if
file does not exist.
ð When
the mode is reading, if the file existed then the file is opened
with the current contents safe otherwise an error occurs.
76.
Input/output operations on Files:
getc and putc functions: the simplest
file I/o functions are getc and putc.
ð „getc‟ is
used to read a char from a file
Example: c=getc(fp1);
ð „putc‟ is
used to write a char to a file
Example: putc(c1,fp1);
EOF – End of file (when EOF
encountered the reading / writing should be terminated)
77.
The getw and putw functions:
These are integer oriented functions.
These are similar to above functions and are used to read and write integer
values. These are useful when we deal with only integer data. The general
format is
putw (integer , fp);
getw(fp);
The fprintf and fscanf functions:
Until now, we handle one char/integer
at a time. But these functions handle a group of mixed data simultaneously.
Syntax of fprintf is
fprintf (fp, “control string”, list);
78.
ð fscanf is used
to read list of items from a file
ð fprintf is used to write a list of items
to a file.
79.
Error handling during I/o operations:
→ During I/o
operations on a file an error may occur. The error may be,
→ Trying to
read beyond the end-of-file
→ Device
overflow
→ Trying to
use a file that has not been opened.
→ If the modes
are not mentioned properly
→ Open a file
with invalid name
→ Try to write contents to a write
protected file
feof and ferror functions
help us to detect I/o errors in the file
ð feof
is used to test
an end of file condition . It takes a FILE pointer as its only argument and
returns a non zero integer value if all the data has been read, and returns
zero otherwise.
Example: if (feof(fp))
printf(“end of data”);
ð ferror
reports the
status of the file indicated . It also takes a FILE pointer as its argument and
returns a non zero integer if an error has been detected up to that point,
during processing , otherwise returns o.
if (ferror(fp)!=0)
printf(“an error has ocured”);
This prints an error message, if
reading is not successful.
80.
Random Access to files:
Until now we read and write data to a
file sequentially. In some situations we need only a particular part of file
and not other parts. This can be done with the help of fseek, ftell,
rewind functions.
81.
ftell: It takes a file pointer and returns
number of type long , that corresponds to the current position. This is useful
in saving the current position of file.
Example: n=ftell(fp);
n’ would give the relative offset (in
bytes) of current position. i.e., n bytes have all ready been
read/ write.
rewind: It takes file pointer and resets the
position to the start of the file.
Example: rewind(fp);
fseek: This function is used to move file
position to a desired location within file.
Syntax: fseek (file pointer, offset,
position)
Example: fseek (Fp1, 0L,); → go to
the beginning
Fseek(fp1,m,1) → go forward by m
bytes
Position 0 ─ beginning
1─ current position
2─ end of file
Offset Positive ─ move forward
Negative ─move backward
OL ─ no more (stay)
If the fseek file
operation is successful, it returns 0 else returns -1 (error
occur)
82.
Command line arguments:
As we know „main‟
function is marked the beginning of the program. This „main‟ can
take two arguments argc and argv and information
contained in the command line is passed on to the program through these
arguments.
→ Argc – is an
argument counter (counts the No. of arguments on the command line)
→ Argv – is am argument rector (array
of char, pointers which points command line)
83.
Dynamic Memory Allocation
Dynamic allocation is a pretty unique
feature to C (amongst high level languages). It enables us to create data types
and structures of any size and length to suit our programs need within the
program.
84.
Malloc, Sizeof, and Free
The Function malloc is most commonly
used to attempt to ``grab'' a continuous portion of memory. It is defined by:
void *malloc(size_t number_of_bytes)
85.
Calloc and Realloc
There are two additional memory
allocation functions, Calloc() and Realloc(). Their prototypes are given below:
void *calloc(size_t num_elements,
size_t element_size};
void *realloc( void *ptr, size_t
new_size);
Realloc is a function which attempts
to change the size of a previous allocated block of memory
malloc does not initialize memory (to
zero) in any way. If you wish to initialize memory then use
calloc. Calloc there is slightly more computationally expensive but,
occasionally, more convenient than malloc
