Chapter 15 Binary and Random Access Files C

Chapter 15 Binary and Random Access Files C++: LEARN BY DOING Todd Breedlove Troy Scevers Randal L. Albert

15. 1 Text Files Versus Binary Files – Comparison • Text files • Readable by humans • Translates information being written to the file into ASCII or Unicode characters • Binary files • Written in a way that requires no translation • Virtually unreadable by humans • Unusable for reports

15. 1 Text Files Versus Binary Files – Hex Dump • Program executables or documents created using Microsoft Word or other word processors are examples of binary files • Visual Studio actually shows a hex dump of binary files • hex dump • Shows contents of a binary file in hexadecimal format as well as a translation of those bytes recognizable as ASCII or Unicode characters

15. 1. 1 Advantages and Disadvantages of Binary Files • Advantages • No need to translate into ASCII characters • Allows special formatting symbols or commands to be placed within the file • Disadvantages • Not directly human readable • Not always portable from one machine to another

15. 2 Opening and Closing Binary Files – Syntax • Opening is similar as text files ifstream in. File ( filename, mode ); -- OR -ofstream out. File; out. File. open ( filename, mode );

15. 2 Opening and Closing Binary Files – Modes Mode ios: : in ios: : out ios: : app ios: : ate ios: : binary ios: : trunc Description Open file for input. Open file for output. All new output is added at the end of the file. Open file with the file pointer initially set at the end of the file. Data can be written anywhere within the file. Open file in binary mode (the default mode is text). Open file for output. If already exists, it is replaced by the new file. If using ios: : out this is the default unless you specify ios: : app, ios: : ate, or ios: : in.

15. 2 Opening and Closing Binary Files – Examples • When working with binary streams, include the second parameter ios: : binary ifstream input ( "filename. bin", ios: : binary ); ofstream fout; fout. open ( "filename. bin", ios: : out | ios: : binary ); ofstream data ( "c: \data. bin", ios: : out | ios: : app | ios: : binary ); • Multiple file mode flags can be combined using the bitwise OR operator (|) • The binary file in the third example is opened in append mode

15. 2 Opening and Closing Binary Files – Refresher • clear method clears, or resets, the I/O state flags for the stream • When end of a file (EOF) is reached a stream state flag of eofbit is set • Attempt to reuse a stream object requires clearing this flag • Once done with input and output activities always close the file • Syntax same as used when closing text files • Style note • Common when naming files to use extension of. bin as illustrated in our examples

15. 3 Binary File I/O – Syntax • Reading • Accomplished using an ifstream object stream. read ( char * buffer, streamsize ); • Writing • Accomplished using an ofstream object stream. write ( char * buffer, streamsize ); • First parameter • Information to be written, or buffer to store the information • Must be cast to a char * (i. e. , a character pointer) • Requires an address of a block of memory where every element is one byte long • Second parameter • Number of bytes to be read or written • If EOF marker is encountered before extracting the number of bytes specified, the read method will stop • The gcount member function is used to retrieve the number of bytes read during the last read

15. 3 Binary File I/O – main Example struct EMP { char name[30]; // Use c. String not dynamic short int age; }; const short int NUM_EMPLOYEES = 3; int main ( ) { EMP ray[NUM_EMPLOYEES]; Fill. Array. From. Keyboard ( ray ); Write. To. File ( ray ); Read. From. File ( ray ); Print. Array ( ray ); } return 0;

15. 3 Binary File I/O – Write. To. File Example void Write. To. File ( EMP ray[] ) { ofstream fout ( "binary. bin", ios: : out | ios: : binary ); if ( fout. is_open ( ) ) { fout. write ( reinterpret_cast <char *> (ray), sizeof ( EMP ) * NUM_EMPLOYEES ); fout. close ( ); } else cout << "File not opened" << endl; }

15. 3 Binary File I/O – Read. From. File Example void Read. From. File ( EMP ray[] ) { ifstream fin ( "binary. bin", ios: : in | ios: : binary ); if ( fin. is_open ( ) ) { fin. read ( reinterpret_cast <char *>(ray), sizeof ( EMP ) * NUM_EMPLOYEES ); cout << "Number of bytes read is: " << fin. gcount ( ); fin. close ( ); } else cout << "File not opened" << endl; }

15. 3 Binary File I/O – Explanation • The reinterpret_cast on the previous slide is another form of type casting usually used to convert an address to a different type of address • Discouraged by many programmers because it can be unsafe, it is a necessary evil in this case • Structure should contain only fixed size data members • Do not use pointers as data members until after the next section

15. 4 Record Serialization and Deserialization – Definition • Writing and reading the data that is a fixed size is relatively simple • With dynamic c. Strings it is not enough to write the data, it also must have information to be able to recreate the dynamic c. String • Serialization • The process of converting a record into a stream of bytes to store the data into a file • Its main purpose is to save the data in order to be able to recreate it when needed • Deserialization • Recreating the data from a stream of bytes

15. 4 Record Serialization and Deserialization – Process • Serialization • Write the number of characters in the dynamic c. String • Write the actual string data • Deserialization • Reads the number of characters in the c. String • Dynamically allocate memory of the correct size • Read the data from the binary file • It is also common practice to write the number of records as the first piece of data in the file

15. 4. 1 Serialization – Step 1 • Write the number of records to the file fout. write ( reinterpret_cast<char *>(&num_faculty), sizeof ( num_faculty ) ); • The figure below is a hex dump from Visual Studio • Highlighted is the data written in little-endian format

15. 4. 1 Serialization – Step 2 • Writing the number of characters in the dynamic c. String // Get length of name including '' str_length = strlen( ray[i]. name ) + 1; // Write out length of name fout. write( reinterpret_cast<char *>( &str_length ), sizeof( str_length ) );

15. 4. 1 Serialization – Step 3 • Writing the faculty member name // Write out the name string // (Note: we do not need a reinterpret cast) fout. write( ray[i]. name, str_length );

15. 4. 1 Serialization – Step 4 • Writing the number of characters in the department name // Get length of department including '' str_length = strlen( ray[i]. department ) + 1; // Write out length of department fout. write( reinterpret_cast<char *>( &str_length ), sizeof( str_length ) );

15. 4. 1 Serialization – Step 5 • Writing the department name // Write out the department string fout. write( ray[i]. department, str_length ); • This entire process repeats for every record in your array

15. 4. 2 Deserialization • Step 1 // First need to read how many elements in dynamic array and create ray fin. read( reinterpret_cast<char *>( &num_faculty ), sizeof( num_faculty ) ); ray = new Faculty[ num_faculty ]; • Step 2 // Read in the length of name and create the memory fin. read(reinterpret_cast<char *>(&length), sizeof(length)); ray[i]. name = new char[length]; // Now read in the name into the array fin. read(ray[i]. name, length); • Step 3 // Read in the length of department and create the memory fin. read( reinterpret_cast<char *>( &length ), sizeof( length ) ); ray[i]. department = new char[length]; // Now read in the department into the array fin. read( ray[i]. department, length );

15. 4. 3 Putting it all Together • We showed a lot of code snippets on the previous slides • This is a great learning tool which shows our penchant for step-wise refinement • However it is also helpful to see an entire working program • This program is shown in Example 15. 4. 9 of the book and can be downloaded from the website

15. 5 Sequential Files vs. Random Access Files • Random access files • Capability to directly access a specific location within a file • Requires ability to move the File Position Marker (FPM) • FPM is a term we use to indicate the current position within the file • Stream objects have their own internal marker for referencing a position within a file • ifstream • Called the get pointer and points to the location of the data that will be read • ofstream • Called the put pointer and indicates location within the file where data will be written

15. 5. 1 Determining Current FPM Location • Two different member functions to determine where the pointer is currently located within a file pos_type stream. tellg( ); pos_type stream. tellp( ); • Return type is a long integer value indicating the number of bytes the FPM is from the start of the file ifstream fin ( "c: \temp\students. bin", ios: : in | ios: : binary ); . . . fin. read ( reinterpret_cast<char *>(student_array), sizeof ( STUDENT ) * 2 ); long int pointer_position = fin. tellg ( ); • If sizeof the STUDENT structure is 56, value returned by tellg would be 112

15. 5. 2 Moving the FPM – seekg and seekp • Member functions seekg and seekp allow positioning the pointer to any location within the file • Both seekp and seekg have multiple definitions stream. seekg( stream. seekp( pos_type off_type position ); offset, ios_base: : seekdir direction );

15. 5. 2 Moving the FPM – Seek Function Parameters • Single parameter form of seekg and seekp positions the FPM so it is the specified number of bytes from beginning of the file • The two parameter form of the seek functions, positions the FPM relative to a specified offset as shown below Direction ios: : beg ios: : cur ios: : end Description Seek (change the current read or write position) relative to the beginning of the file. Seek relative to the current FPM position. Seek relative to the end of the file.

15. 5. 2 Moving the FPM – seekg Example and Explanation fin. seekg ( sizeof( STUDENT ) * 2 ); fin. seekg ( 10, ios: : cur ); • First statement moves the FPM the size of two STUDENT structures from the beginning • Second example sets file marker 10 bytes toward the end of the file relative to the stream’s current FPM

15. 5. 2 Moving the FPM – Opening a File in Mixed Mode • In the following example the fstream object is opened for both input and output • fstream • Parent of both ifstream and ofstream classes • Much of the functionality of the children is derived from the parent • Used fstream because of the default modes of the other two classes • To accomplish both reading and writing to the same stream, we used fstream • The code also illustrates how to re-write a record in the file without altering or rewriting the other records

15. 5. 2 Moving the FPM – fstream Example Part 1 void Locate. And. Modify. Record ( ) { EMP temp; // Opening the stream for both input and output fstream emp. File( "binary. bin", ios: : in | ios: : out | ios: : binary | ios: : ate ); if ( emp. File. is_open ( ) ) { // Move FPM to second record from the front emp. File. seekp ( sizeof ( EMP ) * 1 ); cout << "n* Currently at postion: " << emp. File. tellp ( ); emp. File. read ( reinterpret_cast <char *>(&temp), sizeof ( EMP ) ); cout << "n* The name in the second record is: " << temp. name; cout << "n* The age in the second record is: " << temp. age;

15. 5. 2 Moving the FPM – fstream Example Part 2 // Move FPM 0 bytes from beginning of the stream emp. File. seekg ( 0, ios: : beg ); strcpy ( temp. name, "Jamie" ); temp. age = 41; // Write updated data into current (first) position emp. File. write ( reinterpret_cast <char *>(&temp), sizeof ( EMP ) ); emp. File. close ( ); } else cout << "File not opened" << endl; }

15. 6. 1 C The Differences – File Modes • Second parameter to fopen is a c. String representing the file mode • Only modes discussed so far were r, w, and a (read, write and append) • Below are some additional modes Mode r+ w+ a+ Explanation Read and write. File must exist. Read and write. Will create file if possible. Existing data is destroyed. Read and append. Will create file if possible. Existing data is retained. All writing will be done at the end of the file.

15. 6. 1 C The Differences – File Modes Example • In addition to the random access modes listed on previous page, code below shows a “b” can be appended to any C file mode c. String to allow access to binary files FILE * input; FILE * fout; FILE * data; input = fopen ( "filename. bin", "rb" ); fout = fopen ( "filename. bin", "w+b" ); data = fopen ( "c: \data. bin", "ab" );

15. 6. 2 C The Differences – fread and fwrite • Functions fread and fwrite are C counterparts to read and write size_t fread ( const void * buffer, size_t item_size, size_t num_items, FILE * fptr); size_t fwrite ( const void * buffer, size_t item_size, size_t num_items, FILE * fptr); • Both functions require an address of the buffer in which the information is stored or will be stored • This address will not need to be type cast because the function accepts a void *, a pointer to anything • Second parameter is the size of one item • Third parameter is the number of items to be written or read • Last parameter is the C file pointer • Both functions return the number of items, not bytes, completely read or written

15. 6. 2 C The Differences – main Example typedef struct { char name[30]; short int age; } EMP; #define NUM_EMPLOYEES 3. . . int main ( ) { EMP ray[NUM_EMPLOYEES]; Fill. Array. From. Keyboard ( ray ); Write. To. File ( ray ); Read. From. File ( ray ); Print. Array ( ray ); } return 0;

15. 6. 2 C The Differences – Write. To. File Example void Write. To. File { FILE * fout; fout = fopen if ( fout != { fwrite ( fclose ( } else printf ( } ( EMP ray[] ) ( "binary. bin", "wb" ); NULL ) ray, sizeof ( EMP ), NUM_EMPLOYEES, fout ); "File not openedn" );

15. 6. 2 C The Differences – Read. From. File Example void Read. From. File ( EMP ray[] ) { size_t num_items = 0; FILE * fin; fin = fopen ( "binary. bin", "rb" ); if ( fin != NULL ) { num_items = fread ( ray, sizeof ( EMP ), NUM_EMPLOYEES, fin ); fclose ( fin ); printf ( "Number of bytes read is: %d", num_items ); } else printf ( "File not openedn" ); }

15. 6. 3 C The Differences – Random Access Functions • Three C functions used to manipulate the FPM within binary files void rewind( FILE * stream ); long ftell( FILE * stream ); int fseek( FILE * stream, long offset, int origin ); • The rewind function moves the FPM back to the beginning of the file • ftell returns number of bytes the FPM is currently from the beginning of the file • fseek repositions the FPM within the file

15. 6. 3 C The Differences – Origin Parameter • The origin parameter of fseek can have one of three values as shown below Identifier Description SEEK_CUR Position FPM relative to the current position. SEEK_END Position FPM relative to the end of the file. Position FPM relative to the beginning the file. SEEK_SET

15. 6. 3 C The Differences – Example Part 1 void Locate. And. Modify. Record ( ) { EMP temp; // Opening the stream for both input and output FILE * emp. File = fopen ( "binary. bin", "r+b" ); if ( emp. File != NULL ) { // Move to the beginning of the file rewind ( emp. File ); // Move FPM to second record from the front fseek ( emp. File, sizeof ( EMP ), SEEK_SET ); printf ( "n* Currently at postion: %ld", ftell ( emp. File ) ); fread ( &temp, sizeof ( EMP ), 1, emp. File ); printf ( "n* The name in the second record is: %s", temp. name ); printf ( "n* The age in the second record is: %d", temp. age );

15. 6. 3 C The Differences – Example Part 2 // Move FPM 0 bytes from beginning of the stream fseek ( emp. File, 0, SEEK_SET ); strcpy ( temp. name, "Jamie" ); temp. age = 41; // Write updated data into current (first) position fwrite ( &temp, sizeof ( EMP ), 1, emp. File ); fclose ( emp. File ); } else printf ( "File not opened" ); }