A course in c programming Diarmuid O' Ríordáin, be, mengSc, miei
Download 0.6 Mb.
|
- Navigate this page:
- Opening and Closing Files
- Reading Writing Characters
- Working with strings of text
- APPENDIX A : ASCII Character Set
Chapter 8Standard File I/OThe C standard library I/O functions allow you to read and write data to both files and devices. There are no predefined file structures in C, all data being treated as a sequence of bytes. These I/O functions may be broken into two different categories : stream I/O and low-level I/O. The stream I/O functions treat a data file as a stream of individual characters. The appropriate stream function can provide buffered, formatted or unformatted input and output of data, ranging from single characters to complicated structures. Buffering streamlines the I/O process by providing temporary storage for data which takes away the burden from the system of writing each item of data directly and instead allows the buffer to fill before causing the data to be written. The low-level I/O system on the other hand does not perform any buffering or formatting of data --instead it makes direct use of the system's I/O capabilities to transfer usually large blocks of information. 8.1 Stream I/OThe C I/O system provides a consistent interface to the programmer independent of the actual device being accessed. This interface is termed a stream in C and the actual device is termed a file. A device may be a disk or tape drive, the screen, printer port, etc. but this does not bother the programmer because the stream interface is designed to be largely device independent. All I/O through the keyboard and screen that we have seen so far is in fact done through special standard streams called stdin and stdout for input and output respectively. So in essence the console functions that we have used so far such as printf(), etc. are special case versions of the file functions we will now discuss. There are two types of streams : text and binary. These streams are basically the same in that all types of data can be transferred through them however there is one important difference between them as we will see. Text StreamsA text stream is simply a sequence of characters. However the characters in the stream are open to translation or interpretation by the host environment. For example the newline character, '\n', will normally be converted into a carriage return/linefeed pair and ^Z will be interpreted as EOF. Thus the number of characters sent may not equal the number of characters received. Binary StreamsA binary stream is a sequence of data comprised of bytes that will not be interfered with so that a one-to-one relationship is maintained between data sent and data received. Common File Functions
Opening and Closing FilesA stream is associated with a specific file by performing an open operation. Once a file is opened information may be exchanged between it and your program. Each file that is opened has a unique file control structure of type FILE ( which is defined in FILE *fptr ; The fopen() function opens a stream for use and links a file with that stream returning a valid file pointer which is positioned correctly within the file if all is correct. fopen() has the following prototype FILE *fopen( const char *filename, const char *mode ); where filename is a pointer to a string of characters which make up the name and path of the required file, and mode is a pointer to a string which specifies how the file is to be opened. The following table lists some values for mode.
If fopen( ) cannot open "test.dat " it will a return a NULL pointer which should always be tested for as follows. FILE *fp ; if ( ( fp = fopen( "test.dat", "r" ) ) == NULL ) { puts( "Cannot open file") ; exit( 1) ; } This will cause the program to be exited immediately if the file cannot be opened. The fclose() function is used to disassociate a file from a stream and free the stream for use again. fclose( fp ) ; fclose() will automatically flush any data remaining in the data buffers to the file. Reading & Writing CharactersOnce a file pointer has been linked to a file we can write characters to it using the fputc() function. fputc( ch, fp ) ; If successful the function returns the character written otherwise EOF. Characters may be read from a file using the fgetc() standard library function. ch = fgetc( fp ) ; When EOF is reached in the file fgetc( ) returns the EOF character which informs us to stop reading as there is nothing more left in the file. For Example :- Program to copy a file byte by byte #include void main() { FILE *fin, *fout ; char dest[30], source[30], ch ; puts( "Enter source file name" ); gets( source ); puts( "Enter destination file name" ); gets( dest ) ; if ( ( fin = fopen( source, "rb" ) ) == NULL ) // open as binary as we don’t {// know what is in file puts( "Cannot open input file ") ; puts( source ) ; exit( 1 ) ; } if ( ( fout = fopen( dest, "wb" ) ) == NULL ) { puts( "Cannot open output file ") ; puts( dest ) ; exit( 1 ) ; }
fputc( ch , fout ) ; fclose( fin ) ; fclose( fout ) ; }
This is quite similar to working with characters except that we use the functions fgets() and fputs() whose prototypes are as follows :- int fputs( const char *str, FILE *fp ) ; char *fgets( char *str, int maxlen, FILE *fp ) ; For Example : Program to read lines of text from the keyboard, write them to a file and then read them back again. #include void main() { char file[80], string[80] ; FILE *fp ; printf( "Enter file Name : " ); gets( file ); if (( fp = fopen( file, "w" )) == NULL )//open for writing { printf( "Cannot open file %s", file ) ; exit( 1 ) ; }
{ fputs( str, fp ) ; fputc( '\n', fp ) ; /* must append \n for readability -- not stored by gets() */ }
if (( fp = fopen( file, "r" )) == NULL )//open for reading { printf( "Cannot open file %s", file ) ; exit( 1 ) ; }
puts( str ) ; fclose( fp ) ; }
Formatted I/OFor Example :- Program to read in a string and an integer from the keyboard, write them to a disk file and then read and display the file contents on screen. #include #include void main() { FILE *fp ; char s[80] ; int t ;
{ puts( "Cannot open file test.dat") ; exit(1) ; } puts( "Enter a string and a number") ; scanf( "%s %d", s, &t ); fprintf( fp, "%s %d", s, t ); fclose( fp ) ;
{ puts) "Cannot open file") ; exit(1) ; } fscanf( fp, "%s %d" , s , &t ) ; printf( "%s, %d\n", s, t ) ; fclose( fp ) ; }
stdout --- standard output ie. screen stderr --- again the screen for use if stdout malfunctions
fread() and fwrite()These two functions are used to read and write blocks of data of any type. Their prototypes are as follows where size_t is equivalent to unsigned. size_t fread( void *buffer, size_t num_bytes, size_t count, FILE *fp ) ; size_t fwrite( const void *buffer, size_t num_bytes, size_t count, FILE *fp ) ; where buffer is a pointer to the region in memory from which the data is to be read or written respectively, num_bytes is the number of bytes in each item to be read or written, and count is the total number of items ( each num_bytes long ) to be read/written. The functions return the number of items successfully read or written. For Example :- #include #include struct tag { float balance ; char name[ 80 ] ; } customer = { 123.232, "John" } ; void main() { FILE *fp ; double d = 12.34 ; int i[4] = {10 , 20, 30, 40 } ; if ( (fp = fopen ( "test.dat", "wb+" ) ) == NULL ) { puts( "Cannot open File" ) ; exit(1) ; } fwrite( &d, sizeof( double ), 1, fp ) ; fwrite( i, sizeof( int ), 4, fp ) ; fwrite( &customer, sizeof( struct tag ), 1, fp ) ; rewind( fp ) ; /* repositions file pointer to start */ fread( &d, sizeof( double ), 1, fp ) ; fread( i, sizeof( int ), 4, fp ) ; fread( &customer, sizeof( struct tag ), 1, fp ) ; fclose( fp ) ; }
Random Access I/OThe fseek() function is used in C to perform random access I/O and has the following prototype. int fseek ( FILE *fp, long num_bytes, int origin ) ; where origin specifies one of the following positions as the origin in the operation SEEK_SET --- beginning of file SEEK_CUR --- current position SEEK_END --- EOF
fscanf( fp, "%d", &i ) ; from anywhere in the program. 8.2 Low -- Level I/OLow level file input and output in C does not perform any formatting or buffering of data whatsoever, transferring blocks of anonymous data instead by making use of the underlying operating system's capabilities. Low level I/O makes use of a file handle or descriptor, which is just a non-negative integer, to uniquely identify a file instead of using a pointer to the FILE structure as in the case of stream I/O. As in the case of stream I/O a number of standard files are opened automatically :- standard input --- 0 standard output --- 1 standard error --- 2 The following table lists some of the more common low level I/O functions, whose prototypes are given in
The open function has the following prototype and returns -1 if the open operation fails. int open ( char *filename, int oflag [, int pmode] ) ; where filename is the name of the file to be opened, oflag specifies the type of operations that are to be allowed on the file, and pmode specifies how a file is to be created if it does not exist. oflag may be any logical combination of the following constants which are just bit flags combined using the bitwise OR operator.
pmode is only used when O_CREAT is specified as part of oflag and may be one of the following values S_IWRITE S_IREAD S_IREAD | S_IWRITE This will actually set the read / write access permission of the file at the operating system level permanently unlike oflag which specifies read / write access just while your program uses the file. The close() function has the following prototype int close ( int handle ) ; and closes the file associated with the specific handle. The read() and write() functions have the following prototypes int read( int handle, void *buffer, unsigned int count ) ; int write( int handle, void *buffer, unsigned int count ) ; where handle refers to a specific file opened with open(), buffer is the storage location for the data ( of any type ) and count is the maximum number of bytes to be read in the case of read() or the maximum number of bytes written in the case of write(). The function returns the number of bytes actually read or written or -1 if an error occurred during the operation. Example : Program to read the first 1000 characters from a file and copy them to another. #include #include #include { char buff[1000] ; int handle ; handle=open(" test.dat", O_BINARY|O_RDONLY, S_IREAD | S_IWRITE ); if ( handle == -1 ) return ; if ( read( handle, buff, 1000 ) == 1000 ) puts( "Read successful"); else {
exit( 1 ); }
handle = open("test.bak", O_BINARY|O_CREAT|O_WRONLY| O_TRUNC, S_IREAD | S_IWRITE ) ;
puts( "Write successful") ; else {
exit( 1 ) ; }
}
#include #include #include void main() { int handle ; long length ; char name[80] ; printf( “Enter file name : ” ) ; gets( name ) ; handle=open( name,O_BINARY| O_RDONLY, S_IREAD | S_IWRITE );
length = lseek( handle, 0L, SEEK_END ) ; close( handle ) ; printf( “The length of %s is %ld bytes \n”, name, length ) ; }
8.3 Exercises1. Write a program that determines the following statistics pertaining to a text file.
2. Write a program that computes the value of Sin( x ) for x in the range 0 to 2 in steps of 0.01 radians and stores them in a binary file. This look-up table is commonly used to improve program performance in practical programming rather than calculating values on the spot. Using the standard library random number generator to generate the angles compare the time it takes to ‘calculate’ Sin(x) for 100 values of x using the look-up table and calculating them straight. You might find the standard library time functions useful to compare times accurately.
Write a simple database program which stores and manages information of the type contained in the following structure by making use of a dynamically allocated array / list of structures of this type as described below. typedef struct details { int rec_id ; char name[20] ; char address[80] ; long UCCid ; } DETAILS ; typedef struct list { DETAILS **data_items ; int numrecords ; int selrecord ; } LIST ;
The list structure tells us that there are two records in the list, the current being the first in the list. The pointer mylist->data_items, of type DETAILS **, has been allocated memory to store two addresses, of type DETAILS *, i.e. the addresses for each individual record. Each of these individual pointers, i.e. *(mylist->data_items + i), has been allocated sufficient memory to store an individual record.
2. Search for a record by field in the database. 3. Order the database by field. 4. Retrieve a record from the database. 5. Extract a record from the database, deleting it completely. 6. Save the database appropriately to a file. 7. Load an existing database from a file.
This function should set · void add( LIST *list, DETAILS *new ); This function should add the record pointed to by · DETAILS *probe( LIST *list, int i ) ; This function returns a pointer to the current record and automatically moves you onto the next record. If the current selection is 0, i.e. no record exists in the list, the function should return NULL. If the current selection is otherwise invalid · void extract( LIST *list ); This function removes the current selection completely from the list. It removes nothing if the current record is invalid. · void swap( LIST *list, int i, int j ) ; Swaps records i and j in the list. Note you should only swap the actual addresses of the individual records. · void orderlist( LIST *list, int field ) ; This function should ideally order the complete list in terms of the field given, e.g. in terms of name, UCCid, etc. However it will suffice to do this in terms of name only say. · DETAILS *search( LIST *list, char *item, int field ) ; Search the list from the current position on, for the next occurrence of the searchitem, APPENDIX A : ASCII Character Set
File I/O is not covered until Chapter 8 so this section should be put aside until later. 6th Revision - Directory: cursuri cursuri -> Percy Bysshe Shelley (1792-1822) cursuri -> Abstract This paper is an introduction to specifying robust software components using AsmL, the Abstract State Machine Language. Foundations of Software Engineering Microsoft Research (c) Microsoft Corporation cursuri -> 1. 1 Introduction The definition of the word cursuri -> Molecular structure and properties calculations Download 0.6 Mb. Share with your friends:
|
