Tuesday, August 28, 2018

Managing Data Through Files


The files allow the data to be physically stored on the permanent storage device. Many devices require that information be written to or read from an auxiliary storage [disk: pen drive, hard disk, DVDs] device. Such information is stored on the device in the form of a file. The characteristics of files are:

  • File contents are stored in a permanent storage medium [disk, drum or tape].
  • File data can be of different data types.
  • Files can be arbitrary and of unlimited size.

Organization of files

Files classified into two types, based on the mode of access.

  1. Sequential: in a sequential file all the components are stored in a sequential order. Creating sequential file is easier but accessing file information is slow. In a magnetic tape, only sequential files can be stored.
  2. Random access or direct access: Random access files are those files in which the file information accessed at random. The random files are faster to operate and maintenance of these files easier.

The C language supports both types of files.

Declaring a File

You create a file as a pointer to the file's structure in memory. When you write information to the file, or read information from it, your program gets the information it needs from the structure. To declare a file, use this syntax:

FILE *file_pointer;

FILE *infile , *outfile ;

Here FILE is a constant structure name defined in <stdio.h> file and to deal with file you have to create a pointer variable of this type.

Opening a File

The fopen() function opens the file in user defined mode and passes open file's structure address to file pointer for further processing. This function actually creates link between storage device, computer and the program. The operating system uses FILENAME for file identification and program uses file_pointer for processing the particular file. The fopen() function creates this link and passes control to program for further processing.

file_pointer = fopen ( “FILENAME.Ext” , “mode” );

infile = fopen ( “student.dat” , “w” );   //open file for write operations.

The file can be opened for read only, write only or both, open for append only, create/not create if does not exists and overwrite if exists. These all operations are mentioned in fopen() function using mode type parameter. The following table shows all modes:

Mode

Description

“w”

Open for write operation. If file exist, it deleted and new file created.

“r”

Open for read operation. If file does not exist, NULL/error code returned.

“a”

Open for append operation. New data add at the end of file. If file does not exist, NULL/error code returned.

“r+”

Open existing file for updating.

“w+”

Create new file for read and write operation.

“a+”

Open for append operation. Create file if it does not exists.

Closing a File

To disconnect the link created by fopen() or to close the file C language offers one function called fclose(). This function takes file pointer as its parameter and closes it to prevent any unintentional damage caused by other program activities. 

fclose (file_pointer );

fclose (infile) ; fclose (outfile);

File Operative Functions

The C language provides many library functions to deal with all sort of file operations, viz., read/writing unformatted/formatted character or string or structure. The below table shows such functions:

 Function

Description

putc() , fputc()

To write data to a file/printer, a character at a time.

getc() , fgetc()

To read data from a file/printer, a character at a time.

puts() , fputs()

To write data to a file/printer, a string at a time.

gets() , fgets()

To read data from a file/printer, a string at a time.

 fprintf()

To write formatted data to a file/printer.

fscanf()

To read formatted data from a file/printer.

 fwrite()

To write entire structure to a file/printer.

fread()

To read entire structure from a file/printer.

 


Previous Page Main Contents  

Monday, August 27, 2018

User Defined Data Types

Structures

In real-life scenario, problems are solved by dividing them into different manageable objects and finding solutions to them by following logical manner in efficient way.

Let us see the Student Management System, which stores information of students and allows retrieving, modifying them at operator ease. It has following variables to manipulate student ID [int], student name [string], student address [string], student date-of-birth [int]. Note that all variables are related to single object called student.

Student Management System [using variables]

main()

{

int stNo , i ;

int std_Id[‘ ‘],  std_dob_yy[‘ ‘],  std_dob_mm[‘ ‘],  std_dob_dd[‘ ‘] ;

char std_name[‘ ‘][‘ ‘] ,  std_addr[‘ ‘][‘ ‘] ;

 

printf (“Enter No of students to add:”);

scanf(“%d” , &stNo );

 

for(i=0 ; i < stNo ; i++)

     {

     printf (“ Enter Student ID: “);

scanf (“%d”, &std_id[i] );

     printf (“ Enter Student Name: “); 

scanf (“%s”, &std_name[i] );

     printf (“ Enter Student Address: “); 

scanf (“%s”, &std_address[i] );

     printf (“ Enter Student Dob[dd/mm/yyyy]: “); 

     scanf (“%d/%d/%d”, &std_dob_dd[i] ,

&std_dob_mm[i] , &std_dob_yy[i] );

     }

….

}//end of main

//end of program

 

Even though all variables are part of student object in code they are loosely connect to each other. This is because arrays are used to store each variable data, which takes only one type of data in it. Such programs are very hard to read, maintain and debug. This is not a good example program of modular type.

The efficient approach is creating a student object with all its attributes and then use that object to manipulate the data. It will be easier to write code, find bugs and understand it too! The C language provides two mechanisms for such object creation called structure and union. Both mechanisms allows user to create user-defined object/data type with different variable types grouped together under single name.  

Student Management System [using structure]

main()

{

struct date

  {

  int day;

  int month;

  int year;

  };

 

struct student

  {

  int id ; 

  char name[‘ ‘] ;

  char addr[‘ ‘] ;

  struct date dob;

  };

 

int stNo , i ;

 

//create student object array

struct student std[100];

 

printf (“Enter No of students to add:”);

scanf(“%d” , &stNo );

 

for(i=0 ; i < stNo ; i++)

  {

  printf (“ Enter Student ID: “); 

scanf (“%d”, &std[i].id );

  printf (“ Enter Student Name: “);

scanf (“%s”, &std[i],name );

  printf (“ Enter Student Address: “);

scanf (“%s”, &std[i].address );

  printf (“ Enter Student Dob[dd mm yyyy]: “); 

  scanf (“%d %d %d”, &std[i].dob.dd ,

&std[i].dob.mm , &std[i].dob.yy );

  }

….

}//end of main

//end of program

 

Declaring Structures

The structure is made of many parts: key word struct, tag name, template or body, its objects declaration and template’s terminator symbol semicolon.

There are three steps in constructing and using structures: declare template, create objects from that template, and lastly use or access the objects [not template].

The body of structure is call template, as it acts as standard formatted memory map for all its objects. Whenever new object created, this template reserves set of memory for objects storage.

struct 

{

type member_name_1;

type member_name_2;

…..

type member_name_n;

} object1,object2;

struct        

     {

     int id ; 

     char name[‘ ‘] ;

     char addr[‘ ‘] ;

     struct date dob;

     }std1,std2,std3;

Declaring & creating structure template & objects in one step

 

 

 

 

 

 

 

 

std1.id = 1234;

strcpy(std1.name, “ Michael”);

strcpy(std1.addr, “JainCollege”);

std1.dob.day = 15;

std1.dob.month = 08;

std1.dob.year = 1947;

struct student std1

     {

     1234,

     Michael,

     JainCollege,

     15,

     08,

     1947

     };

 

struct student std1 =  

          {1234,     Michael, JainCollege, 15, 08, 1947 };

 

printf(“Enter student ID: ”);

scanf(“%d”,&std1.id);

printf(“Enter student Name: ”);

scanf(“%s”,&std1.name);

printf(“Enter student Address: ”);

scanf(“%s”,&std1.addr);

printf(“Enter Date of Birth[dd mm yyyy]: ”);

scanf(“%d/%d/%d”, &std1.dob.day,

                &std1.dob.month, &std1.dob.year);

 

Different methods of structure initialization.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

The tag name is optional if objects are also declaring at the time of structure creation.

Initializing & Accessing of Structures

Accessing structure fields [they are always part of structure, so refereed along with object name] with the help of dot ‘.’ operator.

The initialization of structure is done at the time of template creation or at object creation or elsewhere in code.

Functions & Structures

Passing Structure Elements to functions is as simple as passing any in-built data type variable. The data type and name of structure element entry will enough to pass them.

displayStudent(int id, char name[10]); //function prototype

 

main()

{

.....

struct student std1;//create (student type) object

….

displayStudent(std1.id, std1.name);       

//call display student info function

.....

}//end of main

 

//user-defined function implementation

void displayStudent(int s_id, char s_name[25])

{

printf("%d \t %s \n", s_id , s_name );

}

Passing whole structure object to functions is also as simple as passing any in-built data type variable. The data type as struct and name of structure object entry will enough to pass them. The function treats it as student object and accesses all its fields as normally done. However, the passing structure must be declared as global, so that it can be accessed by called function.

struct student {   //student struct must be global

......

};  

displayStudent(struct student x);

//function prototype

 

main()

{

struct student std1;//create (student type) object

….

dislayStudent(std1);//display student info to user

....

}//end of main

 

//user-defined function implementation

void dislayStudent(struct student s)

{

printf("%d %s %s %d-%d-%d \n",

s.id , s.name, s.addr, s.dob.day, s.dob.month, s.dob.year );

}

Returning whole structure object from functions is also as simple as returning any in-built data type variable. Including the name of structure’s object as return data-type in function signature, will enough. However, the passing structure must be declared as global, so that it can be accessed by called code block.

struct student {   //student struct must be global

......

};  

student getStudentInfo(int id);//function prototype

 

main()

{

struct student std1;//create (student type) object

….

std1 = getStudentInfo(5);            

//get  student info by his id=5

printf("%d %s %s %d-%d-%d \n", //display got info

std1.id,std1.name,std1.addr,std1.dob.day,std1.dob.month,std1.dob.year);

 

....

}//end of main

 

//user-defined function implementation

student getStudentInfo(int s_id)

{

struct student s;  //create student object.

s.id = s_id;       //assign received id to object.

strcpy(s.name,”defaultName”);    

//fill default values to other members.

......

return(s);

}

Array of Structures

As arrays stores similar data-type variables, declaring array of structures is also possible. Therefore, to store & manipulate 120 students information is very easy if they are declared as array of type student. Accessing them is same as any array element along with structure element dot operator.

struct student         

{

     int id ; 

     char name[‘ ‘] ;

     char addr[‘ ‘] ;

     struct date dob;

     } std[100];

.....

std[1].id = 2;

strcpy(std[1].name, “Munna.Micheal”);

Pointers of Structures

The pointer variables are used as member of structure or to refer structure object. The pointer variable with structure can be used to construct a complex data structure such as linked lists, doubly linked lists, binary tree etc.

The syntax to declare structure’s pointer variable to object is as follows:

struct tag_name  *variable_name;

The pointer variable accesses its members as following two methods:

(*object_name).field_name = sname ;

The parentheses is necessary as '.' or member operator has high precedence.  Alternatively, using arrow operator [made of minus sign & greater than sign] code can access members of structure.

object_name->field_name = sname ;

The code example is as shown below:

main()

{

struct complex

     {

     int x ;

     int y ;

     };

 

struct complex *ptrc1;

//create complex type pointer object

//(*ptrc1).x = 5; (*ptrc1).y = 10;

 

//get input from user

printf(" Enter Complex No.[real imaginary]:\n" );

scanf("%d %d", &(*ptrc1).x , &(*ptrc1).y );

 

//display inputted number to user

printf(" %d \t %d \n", ptrc1->x , ptrc1->y );

 

}//end of main

Unions

 

The shirt is also an object and it has property called its size: either it will be small, medium, large or extra large. Not all at a time. To store such objects if structure is used, waste of memory will occur as it allocates total template memory size for each object creation.

To store such objects where storage sharing is necessary C language provides one mechanism called Union. It is similar to structure, but it’s all elements share longest length for their storage. Hence, the name given Union.

Comparison of struct and union

 

struct ItemInfo

     {

     char sItem ;  //1 byte

     int mItem ;   //2 bytes

     float bItem ; //4 bytes

     }item;

 

//total memory reserved by struct template is

// 1 + 2 + 4 = 7 bytes per object

union ItemInfo

     {

     char sItem ;  //1 byte

     int mItem ;   //2 bytes

     float bItem ; //4 bytes

     }item;

 

//total memory reserved by union template is

// longest size = 4 bytes per object

 

 

 

 

 

 

 

 

 

All other processes with union are same as structure type. Creating Union object and then initialzing it at some other place is as shown below:

union ItemInfo item1, item2,item3;

.....

// initializing union member

item1.sItem =  'A';

item2.mItem = 3456;

item3.bItem = 789.2334

It is possible that creating Union object and initialzing it at same instance is as shown below:

//creating union object and initializing it

union ItemInfo item1 = { 'A'};

union ItemInfo item2 = { 3456};

union ItemInfo item3 = { 789.2334};

Bit-fields

Suppose employee information program needs to store sex of the employee in its database, and it should be either male or female only. Then programmer has to declare sex variable as char data type, that takes only one byte.

int sex;                  //2 bytes memory = 2 x 8 bits = 16 bits

char sex;      //1 byte memory = 1 x 8 bits = 8 bits

 

However, sex data is having information quantity of two: male or female and needs only one bit of memory to store it! [Sex =0 for male and 1 for female].

Since C is mid-level language, it allows programmer to store data in bit level also. That means programmer can specify the variable size in bits also. The syntax is as follows:

modifier data_type variable_name : bitfieldsizenumber;

unsigned int sex:1;   

//1 bit is used, If sex=0 male and sex=1 female

unsigned int year:7;  

//7 bits are sufficient to store any year value.

Even though bit filed optimizes the code to minimum memory load, they are not recommended in common programming practice. Because not all chips are bit filed addressable and hence code will not be portable in nature. The packing of bits is again machine dependent, either left to right or right to left. This mechanism is widely applied usually in embedded systems where target micro-controller chip is fixed or from same family 8051 or AVR or ARM etc and memory availability is very limited.

One more restriction with bit-field is, the value cannot be directly assigned to it, as it is bit addressable. Code has to read value into a temporary variable and then assign its value to the bit-field.

int s;                   //temporary variable                     

//get info from user

printf("Male: 0     Female:1  \? :" );

scanf( "%d", &s );   //store sex value

sex = s ; //transfer sex value to bit-field variable

The bit-field implementation is applied to any variable declaration in program, whether inside function, structure, or union.

typedef: user-defined alias statement

The typedef statement is use when one wants to refer to a variable type by an alternative name, or alias. This is often makes a great convenience for the programmer where application is made of many code files and programmers.

The typedef feature allows users to define new data types that are equivalent to existing data types. Once a user-defined data type has been established, then new variables, arrays, structures, and so on, can be declared in terms of this new data type.

typedef data_type new_type_name;

 

typedef float real;

//declare float data-type alias, real=float.   

real salary, irate, avg;    

// salary, irate, avg are all float type now.

 

The typedef feature makes programme more readable and secured one.

#define 32bit_System

#ifdef 32bit_System

     typedef char items;

#elseif

     typedef int items;

#endif

.....

items itemId, itemLocation, itemColor;

 

uncomment this directive, if system is 64 bit system

Code file for 32-bit system, all items are 1-byte length and hence char data type is used.

 

Code file for 64-bit system, all items are 2-byte length and hence int data type is used.

Usage of typedef. It makes code more readable, manageable, modular, and portable.

 

 

 

 

 

 

 

 

 

 

 

The typedef feature is particularly convenient when defining structures, since it eliminates the need to repeatedly write struct tag whenever a structure is referenced. As a result, the structure can be referenced more concisely.

Enum: user-defined data type

The enumerated data types helps programmer to write code easily/clearly as they represent integer type value in code.

enum flavours{ sweet, sour, salty=6, pungent, hot, bitter} pickles;

actual int values       =0     =1          =6           =7   =8      =9

enum weekdays{ Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday};

actual int values              =1           =2                =3            =4        =5           =6        =7

enum colours    { red, yellow, green, blue, white, black, ...,};

actual int values       =1       =2       =3    =4       =5      =6            

The declaring enumerated data type is simple as it contains following elements: enum keyword, name, members separated by comma with their position value between flower brackets, and terminator symbol semicolon.

enum user-defined-name { member_name1, m_n2,......};

enum weekdays

{Monday,Tuesday,Wednesday,Thursday,Friday,Saturday, Sunday};

An enumeration is a data-type similar to a structure or a union. Its members are constants that are written as identifiers, though they have signed integer value. The default value of members-of- weekday enum is as follows:

enum weekday { mon , tue , wed , thu , fri , sat };

member value is      =0        =1        =2       =3       =4       =5

This can be change to any desired value in any order.

enum weekday { mon=1 , tue , wed , thu , fri , sat };

member value is      =1            =2       =3       =4       =5        =6

 

enum colors {red=1, blue, green=8, violet, pink};

member value is   =1        =2        =8             =9           =10

Object creation and accessing its members is done as any structure or union object creation is done, as follows:

//declare weekdays enum data-type

enum weekday { mon , tue , wed , thu , fri , sat };

 

//create weekdays objects/variables

weekdays day1, day2, day3;

 

//access each member of enum object’s

int today, lastlogin;

today = day1.mon;         //today=0

lastlogin = day2.fri;     //lastlogin=4

Though the C compiler stores enumerated values as integer constants, enum variables are a distinct type, and they should not be thought of as ints.


Previous Page Main Contents Next Page