FILE MANAGEMENT IN C
FILE
A FILE IS A PLACE ON THE DISK WHERE A GROUP OF RELATED DATA IS STORED. LARGE AMOUNT OF DATA STORED AND READING IS DONE BY A FILE. THE MAIN OPERATION IN FILE ARE,- NAMING A FILE
- OPENING A FILE
- READING DATA FROM A FILE
- WRITING DATA TO A FILE
- CLOSING A FILE
DEFINING AND OPENING A FILE
FILE NAME
FILE NAME IS A STRING OF CHARACTERS THAT MAKE UP A VALID FILE NAME FOR THE OPERATING SYSTEM.EXAMPLE :
STUDENT.DATA
STUDENT.C
PROGRAM.CPP
DATA STRUCTURE
DATA STRUCTURE OF A FILE IS DEFINED AS FILE IN THE LIBRARY OF STANDARD I/O FUNCTION DEFINITIONS. ALL FILES SHOULD BE DECLARED AS TYPE FILE BEFORE THEY ARE USED.SYNTAX :
FILE * FP;
FP = FOPEN( " FILE NAME", "MODE");
PURPOSE
IT SPECIFIES THE PURPOSE OF OPENING A FILE. THE MODE DOES THIS JOB. MODE CAN BE ONE OF THE FOLLOWING.R - OPEN THE FILE FOR READING ONLY.
W - OPEN THE FILE FOR WRITING ONLY.
A - OPEN THE FILE FOR APPENDING ( OR ADDITION / ADDING ) DATA TO IT.
ADDITIONAL MODE OF OPERATION
R+ - THE EXISTING FILE IS OPENED TO THE BEGINNING FOR BOTH READING AND WRITING.W+ - SAME AS W EXCEPT BOTH READING AND WRITING.
A+ - SAME AS A EXCEPT BOTH READING AND WRITING.
CLOSING A FILE
A FILE MUST BE CLOSED AS SOON AS ALL OPERATIONS ON IT HAVE BEEN COMPLETED.SYNTAX :
FCLOSE ( FILE POINTER );
EXAMPLE :
FILE * P1, * P2;
P1 = FOPEN( " INPUT " , " W " );
P2 = FOPEN(" OUTPUT ", " R " );
---------------------
---------------------
---------------------
FCLOSE( P1 );
FCLOSE( P2 );
INPUT OUTPUT OPERATION ON FILE
THE GETC AND PUTC FUNCTIONS
THE SIMPLEST FILE I/O FUNCTIONS ARE GETC AND PUTC. THESE ARE ANALOGOUS TO GETCHAR AND PUTCHAR FUNCTIONS AND HANDLE ONE CHARACTER AT A TIME.PUTC IS USED TO WRITE A CHARACTER FROM A FILE THAT HAS BEEN OPENED IN WRITE MODE.
EXAMPLE : PUTC( C, FP1 );
GETC IS USED TO READ A CHARACTER FROM A FILE THAT HAS BEEN OPENED IN READ MODE.
EXAMPLE : C = GETC( FP2 );
EXAMPLE :
# INCLUDE < STDIO.H >
# INCLUDE < CONIO.H >
VOID MAIN( )
{
FILE * F1;
CHAR C;
PRINTF( " DATA INPUT \N\N " );
/* OPEN THE FILE INPUT */
F1 = FOPEN ( " INPUT ", " W " );
/* GET A CHARACTER FROM KEYBOARD */
WHILE( C = GETCHAR( ) ) ! = EDF )
/* WRITE A CHARACTER TO INPUT */
PUTC( C, F1 );
/* CLOSING THE FILE INPUT */
FCLOSE( F1 );
PRINTF( " \N DATA OUTPUT \N \N " );
/* RE OPEN THE FILE INPUT */
F1 = FOPEN( " INPUT ", " R " );
/* READ A CHARACTER FROM INPUT */
WHILE( C = GETC( ) ! = EDF )
/* DISPLAY A CHARACTER ON SCREEN */
PRINTF( " %C ", C );
/* CLOSE THE FILE INPUT */
FCLOSE( F1 );
}
THE GETW AND PUTW FUNCTIONS
THE GETW AND PUTW ARE INTEGER ORIENTED FUNCTION. THEY ARE SIMILAR TO THE GETC AND PUTC FUNCTIONS AND ARE USED TO READ AND WRITE INTEGER VALUES. THESE FUNCTION WOULD BE USEFUL ONLY FOR INTEGER DATA.SYNTAX OF PUTW :
PUTW( INTEGER, FP );
SYNTAX OF GETW :
GETW( FP );
THE FPRINTF AND FSCANF FUNCTIONS
THE FPRINTF AND FSCANF FUNCTIONS CAN HANDLE A GROUP OF MIXED DATA SIMULTANEOUSLY.
SYNTAX OF FPRINTF :
FPRINTF( FP, " CONTROL STRING ", LIST );
SYNTAX OF FSCANF :
FSCANF( FP, " CONTROL STRING ",LIST );
EXAMPLE :
# INCLUDE < STDIO.H >
# INCLUDE < CONIO.H >
VOID MAIN( )
{
FILE * F1, * F2, * F3;
INT NUMBER, I;
PRINTF( " CONTENTS OF DATA FILE \N \N " );
F1 = FOPEN( " DATA ", " W " );
/* READ DATA FILE */
FOR( I = 1; I < = 30; I++ )
{
SCANF( " %D ", & NUMBER );
IF ( NUNMBER = = -1 )
BREAK;
PUTW ( NUMBER, F1 );
}
FCLOSE( F1 );
F1 = FOPEN( " DATA ", " R " );
F2 = FOPEN( " ODD ", " W " );
F3 = FOPEN( " EVEN ", " W " );
WHILE( NUMBER = GETW( F1 ) ! = EDF )
{
IF ( NUMBER % 2 = = 0 )
PUTW( NUMBER, F3 );
ELSE
PUTW( NUMBER, F2 );
}
FCLOSE( F1 );
FCLOSE( F2 );
FCLOSE( F3 );
F2 = FOPEN( " ODD " , " R " );
F3 = FOPEN( " EVEN " , " R " );
PRINTF( " \N \N CONTENTS OF ODD FILE \N \N " );
WHILE( NUMBER = GETW ( F2 ) ! = EDF )
PRINTF( " %D ", NUMBER );
PRINTF( " \N \N CONTENTS OF EVEN FILE \N \N " );
WHILE( NUMBER = GETW( F3 ) ! = EDF )
PRINTF( " %D ", NUMBER );
FCLOSE( F2 );
FCLOSE( F3 );
}
CODE MASTER
Comments
Post a Comment