{"id":213,"date":"2018-07-11T05:04:20","date_gmt":"2018-07-11T05:04:20","guid":{"rendered":"http:\/\/itp1.epgpbooks.inflibnet.ac.in\/?post_type=chapter&p=213"},"modified":"2018-07-13T09:30:38","modified_gmt":"2018-07-13T09:30:38","slug":"binary-files-in-c","status":"publish","type":"chapter","link":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/chapter\/binary-files-in-c\/","title":{"rendered":"Binary Files in C++"},"content":{"raw":"
\r\n\r\nIntroduction<\/strong>\r\n\r\n \r\n\r\nAs explained in \u2018File I\/O\u2019 module, files are used for persistent data storage. File I\/O facilitates transfer of data between secondary memory (hard disk) and main memory.\r\n\r\n \r\n

In C++, there can be two types of files: Text files and Binary files. Text files are discussed at length including examples in \u2018File I\/O\u2019 module. Our level of comfort lies only with proper ASCII or UNICODE characters, as they are human readable.<\/p>\r\n \r\n\r\nIn this module, we will see working with binary files in detail.\r\n\r\n \r\n\r\nBinary File<\/strong>\r\n\r\n \r\n\r\nBinary file is a file with data stored in raw format, the way it is stored in memory.\r\n\r\n \r\n\r\nFor example, numbers are stored in binary in memory. They are not converted to text (ASCII characters) when writing to binary file.\r\n\r\n \r\n\r\nThe data in binary format is not human readable and cannot be read or modified using text editors.\r\n\r\n \r\n\r\nAdvantages of using binary file over text file\r\n\r\n \r\n\r\nText files perform formatted I\/O; whereas binary files perform unformatted I\/O with raw data. Thus conversion between binary format and ASCII text format do not take place in case of binary files.\r\n\r\n \r\n\r\nSee following example to understand this.\r\n\r\n \r\n\r\nConsider integer value 65536. When read from keyboard, it is entered using keys \u20186\u2019, \u20185\u2019, \u20185\u2019, \u20183\u2019, \u20186\u2019 as ASCII characters. But in memory, data is stored in binary format as 0x\u20190001FFFF\u2019.\r\n\r\n \r\n\r\nInteger 65536 stored as text (using 5 ASCII characters):\r\n\r\n \r\n\r\n\r\n\r\n\r\n\r\n
Character<\/td>\r\n\u20186\u2019<\/td>\r\n\u20185\u2019<\/td>\r\n\u20185\u2019<\/td>\r\n\u20183\u2019<\/td>\r\n\u20186\u2019<\/td>\r\n<\/tr>\r\n
ASCII in Binary<\/td>\r\n00000110<\/td>\r\n00000101<\/td>\r\n00000101<\/td>\r\n00000011<\/td>\r\n00000110<\/td>\r\n<\/tr>\r\n
ASCII in Hexa<\/td>\r\n06<\/td>\r\n05<\/td>\r\n05<\/td>\r\n03<\/td>\r\n06<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\n \r\n\r\n \r\n\r\nInteger 65536 stored as binary in memory (assuming long int, using 4 bytes):\r\n\r\n \r\n\r\n\r\n\r\n\r\n
In Binary<\/td>\r\n00000000<\/td>\r\n00000001<\/td>\r\n11111111<\/td>\r\n11111111<\/td>\r\n<\/tr>\r\n
In Hexa<\/td>\r\n00<\/td>\r\n01<\/td>\r\nFF<\/td>\r\nFF<\/td>\r\n<\/tr>\r\n<\/tbody>\r\n<\/table>\r\nWhen writing the output on screen, it requires converting data stored in memory to text.\r\n\r\nThus, 0x\u20190001FFFF\u2019 is converted to 5 characters \u20186\u2019, \u20185\u2019, \u20185\u2019, \u20183\u2019, \u20186\u2019.\r\n\r\n \r\n\r\nThus, working with text files requires conversion from binary to text or vice versa.\r\n\r\n \r\n\r\nWhen data is stored in binary file, it does not require such conversion. Integer 65536 is stored as 0x\u20190001FFFF\u2019 using 4 bytes without any conversion.\r\n\r\n \r\n
    \r\n \t
  • Binary read\/write is faster, as data interpretation or conversion is not required<\/li>\r\n \t
  • Binary file uses fixed size of memory space for specific type of objects<\/li>\r\n<\/ul>\r\nIn text file, number 65536 requires 5 ASCII characters (5 bytes), number 123456789 requires 9 bytes and number 2 requires 1 byte of storage space. In case of binary files, all these numbers requires fixed 4 bytes space, assuming long int data type.\r\n\r\n \r\n\r\nFor larger numbers, binary file uses less space as compared to text files.\r\n
      \r\n \t
    • Binary file helps in protecting data up to some extent<\/li>\r\n<\/ul>\r\n

      The data stored in binary format is not easy to read for humans. Someone may consider this as a drawback, but it helps in protecting data up to some extent. Text files can be easily edited using simple text editors. Binary files cannot be read using text editors.<\/p>\r\n \r\n\r\nIf information such as marks of students or balance in bank account is stored in text files, it can be easily tampered by someone having access rights. If such information is stored in binary files, data cannot be edited using simple text editors.\r\n\r\n \r\n\r\nAs explained above, binary files are more efficient in terms of speed and memory usage.\r\n\r\nMoreover they provide data protection up to certain level.\r\n\r\n \r\n\r\nWhen to use binary files?\r\n\r\n \r\n\r\nEven though most of the programs usually use ASCII text files, there are certain occasions where binary files will be very useful.\r\n\r\n \r\n\r\nBinary files should be preferred in applications like\r\n\r\n \r\n

        \r\n \t
      • Number crunching scientific applications requiring large amount of data to be processed<\/li>\r\n \t
      • Data sensitive applications involving financial data, personal data or scores in exam etc.<\/li>\r\n<\/ul>\r\n \r\n\r\nWorking with binary files<\/strong>\r\n\r\n \r\n\r\nWorking with files in C++ requires the use of file-oriented streams based on classes:\r\n\r\nifstream, ofstream and fstream.\r\n\r\n \r\n
          \r\n \t
        • ifstream (input file stream) for reading only<\/li>\r\n \t
        • ofstream (output file stream) for writing only<\/li>\r\n \t
        • fstream (file stream) for reading as well as writing<\/li>\r\n<\/ul>\r\nAll these classes are defined in fstream file. Thus, to perform file operations in C++, header files <iostream> and <fstream> must be included in a program.\r\n\r\n \r\n\r\nLike text files, working with binary files also requires following operations:\r\n
            \r\n \t
          • open file<\/li>\r\n \t
          • process: read\/write using file, check errors<\/li>\r\n \t
          • close file<\/li>\r\n<\/ul>\r\n \r\n\r\nBefore any operation can take place on a file, it must be opened first. When working with file is finished, it should be closed to avoid loss of data.\r\n\r\n \r\n\r\nOpening binary file requires open mode ios::binary to be specified. Binary input\/output operations can be performed using read() and write() methods.\r\n\r\n \r\n\r\nPerforming error checks is similar to those in text files.\r\n\r\n \r\n\r\nOpening Binary file<\/strong>\r\n\r\n \r\n\r\nOpening binary file is similar to opening text files, but requires specifying ios::binary as additional open mode. A file stream object can be opened in one of two ways.\r\n\r\n \r\n\r\nFirst, supply a file name along with an i\/o mode parameter to the constructor when declaring an object:\r\n\r\n \r\n\r\nSyntax: FileStream FileObject (const char *filename[, int mode][, int prot]);\r\n\r\n \r\n\r\nEx. ifstream myFile (\"data.bin\", ios::in | ios::binary);\r\n\r\n \r\n\r\nSecond, call open method after declaring a file stream object.\r\n\r\n \r\n\r\nSyntax of open(): void open(const char *filename[, int mode][, int prot]);\r\n\r\n \r\n\r\nEx. ofstream myFile; \u2026 myFile.open (\"data2.bin\", ios::out | ios::binary);\r\n\r\n \r\n\r\nEx. fstream myFile (\"data.bin\", ios::in | ios::out | ios::binary);\r\n\r\n \r\n\r\nEither approach will work equally well with ifstream, ofstream or fstream object. In the syntax given here, [] indicates that the mode and prot arguments are optional. Default mode is ios::in for ifstream, ios::out for ofstream and ios::in | ios::out for fstream.\r\n\r\n \r\n\r\nFor binary I\/O, opening with mode flag ios::binary indicate to suppress formatting and conversion.\r\n\r\n \r\n\r\nNote<\/strong>: When working with text files, one may omit the second parameter (the i\/o mode parameter) to use the default mode. However, in order to manipulate binary files, it is necessary to specify the i\/o mode also along with ios::binary mode.\r\n\r\n<\/div>\r\nManipulating binary file\r\n\r\n \r\n\r\nAs binary format does not require type conversion and formatting, conventional text-oriented << and >> operators are not used normally with binary files.\r\n\r\n \r\n\r\nFile streams include member functions read() and write() specifically designed to read and write binary data.\r\n\r\n \r\n\r\nOne may use methods get() and put() to read\/write single character in binary. But, for binary i\/o of numbers and other complex data types like struct or class, it requires using methods read() and write().\r\n\r\n \r\n\r\nFunction write() is a member function of ostream (inherited by ofstream); and read() is a member function of istream (inherited by ifstream). Objects of class fstream have both these member functions available as fstream is derived from ifstrem and ofstream.\r\n\r\n \r\n\r\nSyntax:\r\n\r\n \r\n\r\nistream& istream::read(char* buf, int size)\r\n\r\n \r\n\r\nostream& ostream::write(const char* buf, int size)\r\n\r\n \r\n\r\nAs seen in the syntax, both read() and write() have same parameters.\r\n\r\n \r\n

            Parameter buf is of type char * (pointer to char) and it specifies the starting address of an array of bytes where the read data elements are to be stored or from where the data elements are to be written. Note that first parameter should be a C-type array of characters and not a string type of C++.<\/p>\r\n \r\n\r\nThe size parameter specifies the number of characters to be read or written from\/to file.\r\n\r\n \r\n\r\n1.1.\u00a0 Writing data to binary file<\/strong>\r\n\r\n \r\n\r\nMethod write() can be used to write data to binary file associated with ofstrem or fstrem object.\r\n\r\n \r\n\r\nThe write() method causes specified size of bytes to be written from the given memory location buf to binary file on given stream and moves the file pointer size bytes ahead.\r\n\r\n \r\n\r\nFollowing example writes two numbers in file. First is of type int, and second is of type double. Note that it requires typecasting to (char *) as per syntax. To know the size of an item to be written, one may use sizeof() operator.\r\n\r\n \r\n\r\nExample code segment:\r\n\r\n \r\n\r\nint i = 1234;\r\n\r\n \r\n\r\ndouble d = 12.34;\r\n\r\nofstream fout(\u201cdata.bin\u201d, ios::out | ios::binary);\r\n\r\nfout.write((char *)&i, sizeof(int));\r\n\r\nfout.write((char *)&d, sizeof(double));\r\n

              \r\n \t
            • Writing in a file starts at the position of the \"put\" pointer.<\/li>\r\n<\/ul>\r\n \r\n\r\nIf the put pointer is current at the end of the file, the file is extended. If the put pointer points into the middle of the file, characters in the file are overwritten with the new data.\r\n\r\n \r\n\r\nThe position of the \u201cput\u201d pointer can be known using tellp() method and can be changed using seekp() method.\r\n\r\n \r\n
                \r\n \t
              • The bytes that are written are not interpreted or formatted.<\/li>\r\n \t
              • The write() method do not add carriage return after writing the data.<\/li>\r\n \t
              • The write method does not assume a null terminator at the end of the bytes in buf being written.<\/li>\r\n<\/ul>\r\n

                It writes size bytes from starting address specified in buf irrespective of occurrence of null character. Null terminator may not be there or may be there before size number of bytes, it has no effect.<\/p>\r\n \r\n

                  \r\n \t
                • If an error occurs while writing (for example, out of disk space), the stream is placed in an error state. Such errors are not common and are often not checked, but it is programmer\u2019s responsibility to check such errors. Once error state bit is set, it remains in effect in following file operations. So, programmer should remember to clear the error state of the file stream before next operation. Error state can be reset using clear() method.<\/li>\r\n<\/ul>\r\n \r\n\r\nNote: <\/strong>The data written to a binary file using write( ) can be read accurately using read( ) only.\r\n\r\n \r\n\r\n1.2.\u00a0 Reading data from binary file<\/strong>\r\n\r\n \r\n\r\nUse read() method to read from a binary file associated with fstream or ifstream object.\r\n\r\n \r\n\r\nFunction read() extracts a given number of bytes from the specified stream and store it into the memory pointed to by the first parameter which is a C-type array of characters.\r\n\r\n \r\n\r\nFollowing example reads two numbers (int and double) from binary file. Note typecasting (char *) used to convert address of int or double to pointer to char.\r\n\r\n \r\n\r\nExample code segment:\r\n\r\n \r\n\r\nint i;\r\n\r\n \r\n\r\ndouble d;\r\n\r\nifstream fin(\u201cdata.bin\u201d, ios::in | ios::binary);\r\n\r\n \r\n\r\nfin.read((char *)&i, sizeof(int));\r\n\r\nfin.read((char *)&d, sizeof(double));\r\n\r\nWhen reading data from a file, there are a couple of things to watch out.\r\n\r\n \r\n
                    \r\n \t
                  • It is the responsibility of the programmer to ensure that the buffer is created and is large enough to hold the number of bytes of the data that is being read.<\/li>\r\n<\/ul>\r\nThe following code segment may probably result in a crash. Reading 7 bytes at memory location of x may overwrite next locations after 2 or 4 bytes (depending on size of int).\r\n\r\n \r\n\r\nint x;\r\n\r\n \r\n\r\nifstream infile;<\/strong>\r\n\r\n \r\n\r\ninfile.open(\"data.bin\", ios::binary | ios::in);\r\n\r\n \r\n\r\ninfile.read((char *) &x, 7); \/\/ reads 7 bytes into a cell that is either 2 or 4 bytes long\r\n\r\n \r\n
                      \r\n \t
                    • The bytes that are read are not interpreted, simply stored in memory as read from file.<\/li>\r\n \t
                    • The method does not assume anything about line endings.<\/li>\r\n<\/ul>\r\nMethod reads exactly size number of bytes. If end of line happens to occur before size bytes, it has no effect.\r\n
                        \r\n \t
                      • The read method does not place a null terminator at the end of the bytes that are read in.<\/li>\r\n \t
                      • If an error occurs while reading (for example, reading after the end of a file), the stream is placed in an error state. In such case, one can use the gcount() method to find out the number of characters actually read.<\/li>\r\n<\/ul>\r\n \r\n\r\nOnce a stream goes into an error state, all future read operations will fail. Do not forget to use the clear() method to reset the stream to a usable state.\r\n\r\n \r\n\r\nChecking error in <\/strong>file operation<\/strong>\r\n\r\n \r\n\r\nIn C++, no file operations cause the program to stop. If an error occurs and is not checked, then the program will be running unreliably. Programmer is responsible to check i\/o errors and do the needful.\r\n\r\n \r\n\r\nTesting for errors, either check error state bits or use methods like good(), fail() etc.\r\n\r\n \r\n\r\nA special method is_open() can be used to check whether opening file is successful or not. Method is_open() returns true if open is successful\r\n\r\n \r\n\r\nFor all other i\/o operations, error can be checked using one of the following:\r\n
                          \r\n \t
                        • Method good() returns true if operation is successful. None of the bits\/flags is set in error state.<\/li>\r\n \t
                        • Method fail() returns true when operation is unsuccessful, i.e. if failbit or badbit is set.<\/li>\r\n \t
                        • Method bad() returns true when operation is unsuccessful, i.e. if badbit is set.<\/li>\r\n \t
                        • Method eof() returns true when end of file is reached, i.e. if eofbit is set.<\/li>\r\n \t
                        • Operator ! returns true when operation is unsuccessful, like fail()<\/li>\r\n \t
                        • Stream pointer is null when operation is unsuccessful Examples:<\/li>\r\n \t
                        • if (fobj.is_open()) {\/\/file opened, process} else {\/\/error}<\/li>\r\n \t
                        • if (fobj.good()) {\/\/successful operation, process} else {\/\/error}<\/li>\r\n \t
                        • If (fobj.fail()) {\/\/error} else {\/\/ successful operation, process}<\/li>\r\n \t
                        • If (fobj.bad()) {\/\/error} else {\/\/ successful operation, process}<\/li>\r\n \t
                        • If (fobj.eof()) {\/\/error, end of file} else {\/\/ process}<\/li>\r\n \t
                        • If (!fobj) {\/\/error} else {\/\/ successful operation, process}<\/li>\r\n \t
                        • if (fobj) {\/\/ successful operation, process} else {\/\/error}<\/li>\r\n<\/ul>\r\n \r\n\r\nRemember that once error bit of error state is set, it remains in effect. When checking error in next operation with associated stream, it will show an error even if next operation is successful. So, do not forget to reset the error state flag associated with the stream after an error is encountered. One may use clear() method to reset the error state associated with stream.\r\n\r\n \r\n\r\nExamples of working with binary files\r\n\r\n \r\n\r\n1.3.\u00a0 <\/strong>Program to copy contents of one file to another file using get() and put() methods\r\n\r\n \r\n
                            \r\n \t
                          • \/\/ copy one file to another using get(), put()<\/li>\r\n \t
                          • \/\/ character by character copy<\/li>\r\n<\/ul>\r\n#include <iostream>\r\n\r\n#include<fstream>\r\n\r\nusing namespace std;\r\n\r\n \r\n\r\nint main()\r\n\r\n{\r\n\r\nifstream fin;\r\n\r\nfin.open(\"file1.pdf\", ios::in | ios::binary);\r\n\r\n \r\n\r\nofstream fout;\r\n\r\nfout.open(\"file2.pdf\", ios::out | ios::binary);\r\n\r\nif (! (fin.is_open() && fout.is_open()))\r\n\r\n{ cout << \"Error opening file\u2026\", exit(1); }\r\n\r\n \r\n\r\nchar ch;\r\n\r\nwhile(!fin.eof())\r\n\r\n{ ch = fin.get(); fout.put(ch); }\r\n\r\n \r\n\r\nfin.close();\u00a0\u00a0\u00a0 fout.close();\r\n\r\nreturn 0;\r\n\r\n}\r\n\r\nBefore executing this code, see that the location of input file is same as that of the executable program. Otherwise, use full path.\r\n\r\n \r\n\r\n \r\n\r\n1.4. <\/strong>Program to copy entire content of one file at a time to another file using read() and write()\r\n\r\n \r\n\r\nIf a file is small enough to get accommodated in memory, binary copy can be performed by reading and writing entire file at a time using single read and write operation.\r\n\r\n \r\n\r\nIn program code 9.1, do modifications as shown below and then execute.\r\n
                              \r\n \t
                            • replace statement<\/li>\r\n<\/ul>\r\nfin.open(\"file1.pdf\", ios::in | ios::binary); with\r\n\r\n \r\n\r\nfin.open(\"file1.pdf\", ios::in | ios::binary | ios::ate); \/\/ file pointer at end of file\r\n
                                \r\n \t
                              • replace code<\/li>\r\n<\/ul>\r\nchar ch;\r\n\r\nwhile(!fin.eof())\r\n\r\n{\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ch = fin.get(); fout.put(ch);\u00a0\u00a0\u00a0\u00a0\u00a0 }\r\n\r\n \r\n\r\n \r\n\r\nwith following code\r\n\r\n \r\n\r\nstreampos size;\r\n\r\nchar * buf;\r\n\r\n \r\n\r\nsize=fin.tellg(); buf=new char [size]; \/\/ get size of file and allocate memory of size bytes\r\n\r\nif (buf) \/\/ memory allocation successful\r\n\r\n{\r\n\r\n \r\n\r\nfin.seekg (0, ios::beg); \/\/ pointer at beginning of file fin.read (buf, size); fout.write (buf, size);\r\n\r\n}\r\n\r\nelse {cout << \"error allocating memory\";}\r\n\r\n \r\n\r\n \r\n\r\nHere, input file is opened with ios::ate mode to have file pointer at end. It enables to know the size of file using tellg(); and then memory buffer of that size can be allocated.\r\n\r\n \r\n\r\nNote that the program code size has become larger, but execution will be faster. After all, execution time matters a lot!\r\n\r\n \r\n\r\n1.5. <\/strong>Program to copy one file to another file with one block at a time using read() and write()\r\n\r\nIf a file is very large, it may not possible to get enough memory to allocate. It is safer to copy block by block. Block size should be selected to be large enough to reduce number of read\/write operations, but to get successful memory allocation.\r\n\r\n \r\n\r\nModify program code 9.1 as follows:\r\n\r\n \r\n\r\nreplace code\r\n\r\n \r\n\r\nchar ch;\r\n\r\nwhile(!fin.eof())\r\n\r\n{\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ch = fin.get(); fout.put(ch);\u00a0\u00a0\u00a0\u00a0\u00a0 }\r\n\r\n \r\n\r\n \r\n\r\nwith following code\r\n\r\n \r\n\r\n\/\/copy block by block\r\n\r\nstreampos size = 4096;\r\n\r\nchar buf [4096];\r\n\r\nwhile (!fin.eof())\r\n\r\n \r\n\r\n{ fin.read (buf, size); fout.write (buf, fin.gcount());\r\n\r\n}\r\n\r\n \r\n\r\n1.6.\u00a0 <\/strong>Program to write and read objects in binary file using write() and read() methods\r\n\r\n \r\n\r\nFor examples of objects in binary file, consider class Student as shown below:\r\n\r\n \r\n\r\nclass Student\r\n\r\n{char name[30];\r\n\r\nint marks[7]; \/\/ marks in 7 subjects\r\n\r\npublic:\r\n\r\nvoid GetStudentData()\u00a0 \/\/ input student data\r\n\r\n{\r\n\r\ncout << \"Enter student's name: \";\r\n\r\ncin.getline(name,30);\r\n\r\ncout << \"Enter marks in 7 subjects:\";\r\n\r\nfor (int i=0; i<7; i++) cin >> marks[i];\r\n\r\n}\r\n\r\n \r\n\r\nvoid ShowStudentData() \/\/ display student data\r\n\r\n{\r\n\r\n \r\n\r\ncout << \"Name: \" << name <<endl;\r\n\r\ncout << \"Marks: \";\r\n\r\nfor (int i = 0; i<7; i++) cout << marks[i] << \"\u00a0 \";\r\n\r\ncout << endl;\r\n\r\n}\r\n\r\n \r\n\r\n \r\n\r\nchar * getname() { return name; }\r\n\r\nvoid getMarks ()\r\n\r\n{\r\n\r\ncout << \"Enter marks in 7 subjects:\";\r\n\r\nfor (int i=0; i<7; i++) cin >> marks[i];\r\n\r\n}\r\n\r\n}; \/\/ end class Student\r\n\r\n \r\n\r\nRefer following code to write objects in binary file, read all objects and display. While\r\n\r\nwriting into file, objects are inserted in file at end, so file is to be opened with ios::app\r\n\r\nmode.\r\n\r\nStudent sobj;\r\n\r\n \r\n\r\nvoid writeStudents()\r\n\r\n{\r\n\r\nofstream outfile;\r\n\r\n \r\n\r\noutfile.open(\"student.dat\", ios::out | ios::binary | ios::app); if (!outfile.is_open())\r\n\r\n{ cout << \"Error opening input file\u2026\", exit(1); }\r\n\r\n \r\n\r\nint i,n;\r\n\r\n \r\n\r\ncout << \"How many students to add? \";\r\n\r\ncin >> n;\r\n\r\nfor ( i=0; i<n; i++)\r\n\r\n{\r\n\r\ncin.get(); \/\/ extract enter key\r\n\r\n \r\n
                                  \r\n \t
                                • \/\/ read student data GetStudentData();<\/li>\r\n \t
                                • \/\/ write student data in binary file write ( (char*)&sobj, sizeof(sobj));<\/li>\r\n<\/ul>\r\n}\r\n\r\noutfile.close();\r\n\r\n} \/\/ end addStudents\r\n\r\n \r\n\r\nvoid readStudents()\r\n\r\n \r\n\r\n{\r\n\r\n \r\n\r\nifstream infile(\"student.dat\", ios::in | ios::binary); if (!infile )\r\n\r\n{ cout << \"Error opening input file\u2026\", exit(2); }\r\n
                                    \r\n \t
                                  • \/\/ read from binary file<\/li>\r\n<\/ul>\r\n \r\n\r\ninfile.read( (char*)&sobj, sizeof(sobj));\r\n\r\nwhile (!infile.eof())\r\n\r\n \r\n\r\n{\r\n\r\n\/\/if (infile) \/\/ successful read\r\n\r\nsobj.ShowStudentData();\r\n\r\ninfile.read( (char*)&sobj, sizeof(sobj));\r\n\r\n}\r\n\r\ninfile.close();\r\n\r\n}\r\n\r\n \r\n\r\nint main()\r\n\r\n{\r\n\r\nwriteStudents();\r\n\r\n \r\n\r\nreadStudents();\r\n\r\ncout <<\"Press any key \";\r\n\r\ncin.get(); cin.get();\r\n\r\nreturn 0;\r\n\r\n}\r\n\r\n \r\n\r\nSample output of program is shown below.\r\n\r\n \r\n\r\nHow many students to add? 2\r\n\r\nEnter student's name: Tina\r\n\r\nEnter marks in 7 subjects:45 40 38 47 42 48 39\r\n\r\nEnter student's name: Ali\r\n\r\nEnter marks in 7 subjects:48 43 40 37 36 47 45\r\n\r\nName: Tina\r\n\r\n \r\n\r\nMarks: 45\u00a0 40\u00a0 38\u00a0 47\u00a0 42\u00a0 48\u00a0 39\r\n\r\nName: Ali\r\n\r\nMarks: 48\u00a0 43\u00a0 40\u00a0 37\u00a0 36\u00a0 47\u00a0 45\r\n\r\n \r\n\r\n \r\n\r\n1.6.1. <\/strong>Modify object stored in binary file\r\n\r\n \r\n\r\nAdd function to modify marks of a specified student and write updated record back in binary file as shown here.\r\n\r\n \r\n\r\nvoid modifyMarks()\r\n\r\n{\r\n\r\n\/\/file for read\/write purpose, so use fstream class\r\n\r\nfstream file(\"student.dat\", ios::in | ios::out | ios::binary);\r\n\r\nif (!file )\r\n\r\n{ cout << \"Error opening input file\u2026\", exit(3); }\r\n\r\n \r\n\r\nchar name [40];\r\n\r\n \r\n\r\ncout << \"Enter name of student to modify marks: \"; cin >> name;\r\n\r\n \r\n\r\nfile.read( (char*)&sobj, sizeof(sobj));\r\n\r\nwhile (!file.eof())\r\n\r\n{\r\n\r\nif (strcmp(name, sobj.getname())==0) \/\/ object found\r\n\r\n{\r\n\r\nsobj.getMarks();\r\n\r\n \r\n\r\nlong pos = -1 * sizeof(sobj); \/\/for backward move file.seekp (pos, ios::cur); \/\/back from current file.write ((char*)&sobj, sizeof(sobj));\r\n\r\n \r\n\r\nbreak;\r\n\r\n}\r\n\r\nfile.read( (char*)&sobj, sizeof(sobj)); \/\/read next\r\n\r\n \r\n\r\n}\r\n\r\nfile.close();\r\n\r\n}\r\n\r\n \r\n\r\n \r\n\r\nCalling modifyMarks() and readstudents() in main function will result in the following output:\r\n\r\n \r\n\r\nEnter name of student to modify marks: Tina\r\n\r\nEnter marks in 7 subjects:45 45 46 46 47 47 40\r\n\r\n \r\n\r\nafter modification ...\r\n\r\nName: Tina\r\n\r\nMarks: 45\u00a0 45\u00a0 46\u00a0 46\u00a0 47\u00a0 47\u00a0 40\r\n\r\nName: Ali\r\n\r\nMarks: 48\u00a0 43\u00a0 40\u00a0 37\u00a0 36\u00a0 47\u00a0 45\r\n\r\n \r\n\r\nHere, observe following points in the code:\r\n\r\n \r\n
                                      \r\n \t
                                    • Use of fstream with input as well as output open mode<\/li>\r\n<\/ul>\r\n \r\n\r\nTo modify marks of a specified student, it requires reading student, modifying marks if name is matching, and then writing student object back at the same position. Hence, one should use fstream class object for i\/o strem.\r\n\r\n \r\n
                                        \r\n \t
                                      • Positioning \u201cput\u201d pointer at the beginning of record before writing<\/li>\r\n<\/ul>\r\n \r\n\r\nAfter reading an object, file position is moved sizeof(sobj) bytes ahead. Before writing the updated object back, the position of \u201cput\u201d pointer should be moved sizeof(obj) bytes in backward direction.\r\n\r\n \r\n\r\n1.6.2.<\/strong>\u00a0\u00a0\u00a0 Delete an object from binary file\r\n\r\n \r\n\r\nDeletion of record from a file can be implemented using logical deletion or physical deletion.\r\n\r\n \r\n

                                        For logical deletion of an object, add one data member, say delFlag, in a class to mark the object as deleted. Now deletion is as good as modifying object by setting delFlag to true. A care should be taken while processing, like showing only non-deleted objects.<\/p>\r\n

                                        With physical deletion, an object record is to be removed from file. Due to sequential nature of streams, remaining records are to be shifted. It requires setting \u201cget\u201d and \u201cput\u201d pointer for all remaining records. The simple solution is to write remaining records in one temporary file and copying temporary file back to original file. This can be performed using following steps:<\/p>\r\n \r\n\r\n(i) Create temporary file\r\n\r\n(ii) Read an object from data file\r\n\r\n(iii) If it matches with the specified object to be deleted, do not write in temporary file; otherwise write in temporary file\r\n\r\n(iv) Repeat steps (ii) and (iii) till end of data file\r\n\r\n(v) Close both files\r\n\r\n(vi) Delete original data file\r\n\r\n(vii) Rename temporary file as original data file\r\n\r\n(viii) rename(\"temp.dat\", \"marks.dat\");\r\n\r\n \r\n\r\nRefer following code using physical deletion of records from binary file.\r\n\r\n \r\n\r\nvoid deleteStudent()\r\n\r\n{\r\n\r\n \r\n\r\nifstream infile(\"student.dat\", ios::in | ios::binary); if (!infile )\r\n\r\n{ cout << \"Error opening input file\u2026\", exit(2); }\r\n\r\n \r\n\r\nofstream tmpfile;\r\n\r\n \r\n\r\ntmpfile.open(\"temp.dat\", ios::out | ios::binary); \/\/ copy objects in temp file if (!tmpfile.is_open())\r\n\r\n \r\n\r\n{ cout << \"Error opening input file\u2026\", exit(4); }\r\n\r\n \r\n\r\nchar name [40];\r\n\r\n \r\n\r\ncout << \"Enter name of student to be deleted: \"; cin >> name;\r\n\r\n \r\n\r\ninfile.read( (char*)&sobj, sizeof(sobj));\r\n\r\nwhile (!infile.eof())\r\n\r\n{\r\n\r\nif (strcmp(name, sobj.getname())!=0) \/\/ object not to be deleted\r\n\r\n{\r\n\r\ntmpfile.write ((char*)&sobj, sizeof(sobj));\r\n\r\n}\r\n\r\n \r\n\r\ninfile.read( (char*)&sobj, sizeof(sobj)); \/\/read next\r\n\r\n}\r\n\r\ninfile.close(); tmpfile.close();\r\n\r\nremove(\"student.dat\"); \/\/ remove old student.date file\r\n\r\n \r\n\r\nrename(\"temp.dat\", \"student.dat\"); \/\/ rename temp.dat to student.dat\r\n\r\n}\r\n\r\nWrite following lines in main() and execute program.\r\n\r\n \r\n\r\ndeleteStudent();\r\n\r\ncout << \"\\nafter deletion ... \\n\";\r\n\r\n \r\n\r\nreadStudents();\r\n\r\n \r\n\r\n \r\n\r\nObserve the ouput:\r\n\r\n \r\n\r\nEnter name of student to be deleted: Tina\r\n\r\n \r\n\r\nafter deletion ...\r\n\r\nName: Ali\r\n\r\nMarks: 48\u00a0 43\u00a0 40\u00a0 37\u00a0 36\u00a0 47\u00a0 45\r\n\r\n \r\n\r\n1.6.3. Random access: Reading nth object from binary file<\/strong>\r\n\r\n \r\n\r\nTo access nth object from file without reading previous records, simply position \u201cget\u201d file pointer at (n-1)*sizeof(obj) bytes from beginning of file and read the record as follows.\r\n\r\n \r\n\r\nifstream file;\r\n\r\nfile.open(\"student.dat\", ios::in | ios::binary);\r\n\r\n\/\/input n\r\n\r\nlong pos = (n-1) * sizeof(sobj); \/\/for moving pos bytes ahead from beginning\r\n\r\nfile.seekg (pos);\u00a0 \/\/ from beginning\r\n\r\nfile.read ((char*)&sobj, sizeof(sobj));\r\n\r\nsobj.ShowStudentData();\r\n\r\nfile.close();\r\n\r\n \r\n\r\n \r\n\r\nSummary<\/strong>\r\n

                                          \r\n \t
                                        • Binary files are used for persistent storage of data in raw format o No type conversion or formatting takes place<\/li>\r\n<\/ul>\r\no\u00a0 Data stored in the format as it is stored in main memory\r\n
                                            \r\n \t
                                          • Advantages of binary files over text files\r\n
                                              \r\n \t
                                            • o Faster input\/output operations<\/li>\r\n \t
                                            • o Storage apace efficient<\/li>\r\n \t
                                            • o Not editable using text editors<\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>\r\n
                                                \r\n \t
                                              • While opening, requires ios::binary open mode to be specified alongwith other modes<\/li>\r\n \t
                                              • Input\/output operations can be performed using\r\n
                                                  \r\n \t
                                                • o Methods read() and write() for any type of data; may be numeric, character,<\/li>\r\n<\/ul>\r\n<\/li>\r\n<\/ul>\r\n \r\n\r\nstring, struct, object etc.\r\n
                                                    \r\n \t
                                                  • o Additionally, methods get() and put() can be used to read and write character data<\/li>\r\n \t
                                                  • Random access and file error handling is same as with text files<\/li>\r\n<\/ul>\r\nReferences<\/strong>\r\n\r\n \r\n\r\n \r\n\r\n1) Stanley Lippmann, \u201cC++ Primer\u201d, Pearson Education.\r\n\r\n2) Bjarne Stroustrup, \u201cThe C++ Programming Language\u201d, Pearson Education.\r\n\r\n3) Scott Mayer, \u201cEffective C++\u201d, Addison Wesley.\r\n\r\n4) Bhushan Trivedi , Programming with ANSI C++, 2\/e , Oxford University Press.\r\n\r\n5) Yashavant P. Kanetkar \u201cLet Us C++\u201d , Bpb Publications.\r\n\r\n6) Abhiram G. Ranade, \u201cAn Introduction to Programming through C++\u201d , McGraw Hill\r\n\r\n7) Ellis and B. Stroustrup \u201cAnnotated C++ Reference Manual\u201d, http:\/\/www.stroustrup.com\/arm.html\r\n\r\n8) Herbert Schildt, \u201cComplete Reference C++\u201d, McGraw Hill Publications.\r\n\r\n9) Ashok Kamthane, \u201cObject Oriented Programming with ANSI and Turbo C++\u201d, Pearson Education\r\n\r\n10) E Balaguruswami, \u201cObject Oriented Programming With C++\u201d, Tata McGraw Hill\r\n\r\n11) \u201cC++ FAQs\u201d, Pearson Education.\r\n\r\n ","rendered":"
                                                    \n

                                                    Introduction<\/strong><\/p>\n

                                                     <\/p>\n

                                                    As explained in \u2018File I\/O\u2019 module, files are used for persistent data storage. File I\/O facilitates transfer of data between secondary memory (hard disk) and main memory.<\/p>\n

                                                     <\/p>\n

                                                    In C++, there can be two types of files: Text files and Binary files. Text files are discussed at length including examples in \u2018File I\/O\u2019 module. Our level of comfort lies only with proper ASCII or UNICODE characters, as they are human readable.<\/p>\n

                                                     <\/p>\n

                                                    In this module, we will see working with binary files in detail.<\/p>\n

                                                     <\/p>\n

                                                    Binary File<\/strong><\/p>\n

                                                     <\/p>\n

                                                    Binary file is a file with data stored in raw format, the way it is stored in memory.<\/p>\n

                                                     <\/p>\n

                                                    For example, numbers are stored in binary in memory. They are not converted to text (ASCII characters) when writing to binary file.<\/p>\n

                                                     <\/p>\n

                                                    The data in binary format is not human readable and cannot be read or modified using text editors.<\/p>\n

                                                     <\/p>\n

                                                    Advantages of using binary file over text file<\/p>\n

                                                     <\/p>\n

                                                    Text files perform formatted I\/O; whereas binary files perform unformatted I\/O with raw data. Thus conversion between binary format and ASCII text format do not take place in case of binary files.<\/p>\n

                                                     <\/p>\n

                                                    See following example to understand this.<\/p>\n

                                                     <\/p>\n

                                                    Consider integer value 65536. When read from keyboard, it is entered using keys \u20186\u2019, \u20185\u2019, \u20185\u2019, \u20183\u2019, \u20186\u2019 as ASCII characters. But in memory, data is stored in binary format as 0x\u20190001FFFF\u2019.<\/p>\n

                                                     <\/p>\n

                                                    Integer 65536 stored as text (using 5 ASCII characters):<\/p>\n

                                                     <\/p>\n\n\n\n\n\n
                                                    Character<\/td>\n\u20186\u2019<\/td>\n\u20185\u2019<\/td>\n\u20185\u2019<\/td>\n\u20183\u2019<\/td>\n\u20186\u2019<\/td>\n<\/tr>\n
                                                    ASCII in Binary<\/td>\n00000110<\/td>\n00000101<\/td>\n00000101<\/td>\n00000011<\/td>\n00000110<\/td>\n<\/tr>\n
                                                    ASCII in Hexa<\/td>\n06<\/td>\n05<\/td>\n05<\/td>\n03<\/td>\n06<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                                                     <\/p>\n

                                                     <\/p>\n

                                                    Integer 65536 stored as binary in memory (assuming long int, using 4 bytes):<\/p>\n

                                                     <\/p>\n\n\n\n\n
                                                    In Binary<\/td>\n00000000<\/td>\n00000001<\/td>\n11111111<\/td>\n11111111<\/td>\n<\/tr>\n
                                                    In Hexa<\/td>\n00<\/td>\n01<\/td>\nFF<\/td>\nFF<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

                                                    When writing the output on screen, it requires converting data stored in memory to text.<\/p>\n

                                                    Thus, 0x\u20190001FFFF\u2019 is converted to 5 characters \u20186\u2019, \u20185\u2019, \u20185\u2019, \u20183\u2019, \u20186\u2019.<\/p>\n

                                                     <\/p>\n

                                                    Thus, working with text files requires conversion from binary to text or vice versa.<\/p>\n

                                                     <\/p>\n

                                                    When data is stored in binary file, it does not require such conversion. Integer 65536 is stored as 0x\u20190001FFFF\u2019 using 4 bytes without any conversion.<\/p>\n

                                                     <\/p>\n

                                                      \n
                                                    • Binary read\/write is faster, as data interpretation or conversion is not required<\/li>\n
                                                    • Binary file uses fixed size of memory space for specific type of objects<\/li>\n<\/ul>\n

                                                      In text file, number 65536 requires 5 ASCII characters (5 bytes), number 123456789 requires 9 bytes and number 2 requires 1 byte of storage space. In case of binary files, all these numbers requires fixed 4 bytes space, assuming long int data type.<\/p>\n

                                                       <\/p>\n

                                                      For larger numbers, binary file uses less space as compared to text files.<\/p>\n

                                                        \n
                                                      • Binary file helps in protecting data up to some extent<\/li>\n<\/ul>\n

                                                        The data stored in binary format is not easy to read for humans. Someone may consider this as a drawback, but it helps in protecting data up to some extent. Text files can be easily edited using simple text editors. Binary files cannot be read using text editors.<\/p>\n

                                                         <\/p>\n

                                                        If information such as marks of students or balance in bank account is stored in text files, it can be easily tampered by someone having access rights. If such information is stored in binary files, data cannot be edited using simple text editors.<\/p>\n

                                                         <\/p>\n

                                                        As explained above, binary files are more efficient in terms of speed and memory usage.<\/p>\n

                                                        Moreover they provide data protection up to certain level.<\/p>\n

                                                         <\/p>\n

                                                        When to use binary files?<\/p>\n

                                                         <\/p>\n

                                                        Even though most of the programs usually use ASCII text files, there are certain occasions where binary files will be very useful.<\/p>\n

                                                         <\/p>\n

                                                        Binary files should be preferred in applications like<\/p>\n

                                                         <\/p>\n

                                                          \n
                                                        • Number crunching scientific applications requiring large amount of data to be processed<\/li>\n
                                                        • Data sensitive applications involving financial data, personal data or scores in exam etc.<\/li>\n<\/ul>\n

                                                           <\/p>\n

                                                          Working with binary files<\/strong><\/p>\n

                                                           <\/p>\n

                                                          Working with files in C++ requires the use of file-oriented streams based on classes:<\/p>\n

                                                          ifstream, ofstream and fstream.<\/p>\n

                                                           <\/p>\n

                                                            \n
                                                          • ifstream (input file stream) for reading only<\/li>\n
                                                          • ofstream (output file stream) for writing only<\/li>\n
                                                          • fstream (file stream) for reading as well as writing<\/li>\n<\/ul>\n

                                                            All these classes are defined in fstream file. Thus, to perform file operations in C++, header files <iostream> and <fstream> must be included in a program.<\/p>\n

                                                             <\/p>\n

                                                            Like text files, working with binary files also requires following operations:<\/p>\n

                                                              \n
                                                            • open file<\/li>\n
                                                            • process: read\/write using file, check errors<\/li>\n
                                                            • close file<\/li>\n<\/ul>\n

                                                               <\/p>\n

                                                              Before any operation can take place on a file, it must be opened first. When working with file is finished, it should be closed to avoid loss of data.<\/p>\n

                                                               <\/p>\n

                                                              Opening binary file requires open mode ios::binary to be specified. Binary input\/output operations can be performed using read() and write() methods.<\/p>\n

                                                               <\/p>\n

                                                              Performing error checks is similar to those in text files.<\/p>\n

                                                               <\/p>\n

                                                              Opening Binary file<\/strong><\/p>\n

                                                               <\/p>\n

                                                              Opening binary file is similar to opening text files, but requires specifying ios::binary as additional open mode. A file stream object can be opened in one of two ways.<\/p>\n

                                                               <\/p>\n

                                                              First, supply a file name along with an i\/o mode parameter to the constructor when declaring an object:<\/p>\n

                                                               <\/p>\n

                                                              Syntax: FileStream FileObject (const char *filename[, int mode][, int prot]);<\/p>\n

                                                               <\/p>\n

                                                              Ex. ifstream myFile (“data.bin”, ios::in | ios::binary);<\/p>\n

                                                               <\/p>\n

                                                              Second, call open method after declaring a file stream object.<\/p>\n

                                                               <\/p>\n

                                                              Syntax of open(): void open(const char *filename[, int mode][, int prot]);<\/p>\n

                                                               <\/p>\n

                                                              Ex. ofstream myFile; \u2026 myFile.open (“data2.bin”, ios::out | ios::binary);<\/p>\n

                                                               <\/p>\n

                                                              Ex. fstream myFile (“data.bin”, ios::in | ios::out | ios::binary);<\/p>\n

                                                               <\/p>\n

                                                              Either approach will work equally well with ifstream, ofstream or fstream object. In the syntax given here, [] indicates that the mode and prot arguments are optional. Default mode is ios::in for ifstream, ios::out for ofstream and ios::in | ios::out for fstream.<\/p>\n

                                                               <\/p>\n

                                                              For binary I\/O, opening with mode flag ios::binary indicate to suppress formatting and conversion.<\/p>\n

                                                               <\/p>\n

                                                              Note<\/strong>: When working with text files, one may omit the second parameter (the i\/o mode parameter) to use the default mode. However, in order to manipulate binary files, it is necessary to specify the i\/o mode also along with ios::binary mode.<\/p>\n<\/div>\n

                                                              Manipulating binary file<\/p>\n

                                                               <\/p>\n

                                                              As binary format does not require type conversion and formatting, conventional text-oriented << and >> operators are not used normally with binary files.<\/p>\n

                                                               <\/p>\n

                                                              File streams include member functions read() and write() specifically designed to read and write binary data.<\/p>\n

                                                               <\/p>\n

                                                              One may use methods get() and put() to read\/write single character in binary. But, for binary i\/o of numbers and other complex data types like struct or class, it requires using methods read() and write().<\/p>\n

                                                               <\/p>\n

                                                              Function write() is a member function of ostream (inherited by ofstream); and read() is a member function of istream (inherited by ifstream). Objects of class fstream have both these member functions available as fstream is derived from ifstrem and ofstream.<\/p>\n

                                                               <\/p>\n

                                                              Syntax:<\/p>\n

                                                               <\/p>\n

                                                              istream& istream::read(char* buf, int size)<\/p>\n

                                                               <\/p>\n

                                                              ostream& ostream::write(const char* buf, int size)<\/p>\n

                                                               <\/p>\n

                                                              As seen in the syntax, both read() and write() have same parameters.<\/p>\n

                                                               <\/p>\n

                                                              Parameter buf is of type char * (pointer to char) and it specifies the starting address of an array of bytes where the read data elements are to be stored or from where the data elements are to be written. Note that first parameter should be a C-type array of characters and not a string type of C++.<\/p>\n

                                                               <\/p>\n

                                                              The size parameter specifies the number of characters to be read or written from\/to file.<\/p>\n

                                                               <\/p>\n

                                                              1.1.\u00a0 Writing data to binary file<\/strong><\/p>\n

                                                               <\/p>\n

                                                              Method write() can be used to write data to binary file associated with ofstrem or fstrem object.<\/p>\n

                                                               <\/p>\n

                                                              The write() method causes specified size of bytes to be written from the given memory location buf to binary file on given stream and moves the file pointer size bytes ahead.<\/p>\n

                                                               <\/p>\n

                                                              Following example writes two numbers in file. First is of type int, and second is of type double. Note that it requires typecasting to (char *) as per syntax. To know the size of an item to be written, one may use sizeof() operator.<\/p>\n

                                                               <\/p>\n

                                                              Example code segment:<\/p>\n

                                                               <\/p>\n

                                                              int i = 1234;<\/p>\n

                                                               <\/p>\n

                                                              double d = 12.34;<\/p>\n

                                                              ofstream fout(\u201cdata.bin\u201d, ios::out | ios::binary);<\/p>\n

                                                              fout.write((char *)&i, sizeof(int));<\/p>\n

                                                              fout.write((char *)&d, sizeof(double));<\/p>\n

                                                                \n
                                                              • Writing in a file starts at the position of the “put” pointer.<\/li>\n<\/ul>\n

                                                                 <\/p>\n

                                                                If the put pointer is current at the end of the file, the file is extended. If the put pointer points into the middle of the file, characters in the file are overwritten with the new data.<\/p>\n

                                                                 <\/p>\n

                                                                The position of the \u201cput\u201d pointer can be known using tellp() method and can be changed using seekp() method.<\/p>\n

                                                                 <\/p>\n

                                                                  \n
                                                                • The bytes that are written are not interpreted or formatted.<\/li>\n
                                                                • The write() method do not add carriage return after writing the data.<\/li>\n
                                                                • The write method does not assume a null terminator at the end of the bytes in buf being written.<\/li>\n<\/ul>\n

                                                                  It writes size bytes from starting address specified in buf irrespective of occurrence of null character. Null terminator may not be there or may be there before size number of bytes, it has no effect.<\/p>\n

                                                                   <\/p>\n

                                                                    \n
                                                                  • If an error occurs while writing (for example, out of disk space), the stream is placed in an error state. Such errors are not common and are often not checked, but it is programmer\u2019s responsibility to check such errors. Once error state bit is set, it remains in effect in following file operations. So, programmer should remember to clear the error state of the file stream before next operation. Error state can be reset using clear() method.<\/li>\n<\/ul>\n

                                                                     <\/p>\n

                                                                    Note: <\/strong>The data written to a binary file using write( ) can be read accurately using read( ) only.<\/p>\n

                                                                     <\/p>\n

                                                                    1.2.\u00a0 Reading data from binary file<\/strong><\/p>\n

                                                                     <\/p>\n

                                                                    Use read() method to read from a binary file associated with fstream or ifstream object.<\/p>\n

                                                                     <\/p>\n

                                                                    Function read() extracts a given number of bytes from the specified stream and store it into the memory pointed to by the first parameter which is a C-type array of characters.<\/p>\n

                                                                     <\/p>\n

                                                                    Following example reads two numbers (int and double) from binary file. Note typecasting (char *) used to convert address of int or double to pointer to char.<\/p>\n

                                                                     <\/p>\n

                                                                    Example code segment:<\/p>\n

                                                                     <\/p>\n

                                                                    int i;<\/p>\n

                                                                     <\/p>\n

                                                                    double d;<\/p>\n

                                                                    ifstream fin(\u201cdata.bin\u201d, ios::in | ios::binary);<\/p>\n

                                                                     <\/p>\n

                                                                    fin.read((char *)&i, sizeof(int));<\/p>\n

                                                                    fin.read((char *)&d, sizeof(double));<\/p>\n

                                                                    When reading data from a file, there are a couple of things to watch out.<\/p>\n

                                                                     <\/p>\n

                                                                      \n
                                                                    • It is the responsibility of the programmer to ensure that the buffer is created and is large enough to hold the number of bytes of the data that is being read.<\/li>\n<\/ul>\n

                                                                      The following code segment may probably result in a crash. Reading 7 bytes at memory location of x may overwrite next locations after 2 or 4 bytes (depending on size of int).<\/p>\n

                                                                       <\/p>\n

                                                                      int x;<\/p>\n

                                                                       <\/p>\n

                                                                      ifstream infile;<\/strong><\/p>\n

                                                                       <\/p>\n

                                                                      infile.open(“data.bin”, ios::binary | ios::in);<\/p>\n

                                                                       <\/p>\n

                                                                      infile.read((char *) &x, 7); \/\/ reads 7 bytes into a cell that is either 2 or 4 bytes long<\/p>\n

                                                                       <\/p>\n

                                                                        \n
                                                                      • The bytes that are read are not interpreted, simply stored in memory as read from file.<\/li>\n
                                                                      • The method does not assume anything about line endings.<\/li>\n<\/ul>\n

                                                                        Method reads exactly size number of bytes. If end of line happens to occur before size bytes, it has no effect.<\/p>\n

                                                                          \n
                                                                        • The read method does not place a null terminator at the end of the bytes that are read in.<\/li>\n
                                                                        • If an error occurs while reading (for example, reading after the end of a file), the stream is placed in an error state. In such case, one can use the gcount() method to find out the number of characters actually read.<\/li>\n<\/ul>\n

                                                                           <\/p>\n

                                                                          Once a stream goes into an error state, all future read operations will fail. Do not forget to use the clear() method to reset the stream to a usable state.<\/p>\n

                                                                           <\/p>\n

                                                                          Checking error in <\/strong>file operation<\/strong><\/p>\n

                                                                           <\/p>\n

                                                                          In C++, no file operations cause the program to stop. If an error occurs and is not checked, then the program will be running unreliably. Programmer is responsible to check i\/o errors and do the needful.<\/p>\n

                                                                           <\/p>\n

                                                                          Testing for errors, either check error state bits or use methods like good(), fail() etc.<\/p>\n

                                                                           <\/p>\n

                                                                          A special method is_open() can be used to check whether opening file is successful or not. Method is_open() returns true if open is successful<\/p>\n

                                                                           <\/p>\n

                                                                          For all other i\/o operations, error can be checked using one of the following:<\/p>\n

                                                                            \n
                                                                          • Method good() returns true if operation is successful. None of the bits\/flags is set in error state.<\/li>\n
                                                                          • Method fail() returns true when operation is unsuccessful, i.e. if failbit or badbit is set.<\/li>\n
                                                                          • Method bad() returns true when operation is unsuccessful, i.e. if badbit is set.<\/li>\n
                                                                          • Method eof() returns true when end of file is reached, i.e. if eofbit is set.<\/li>\n
                                                                          • Operator ! returns true when operation is unsuccessful, like fail()<\/li>\n
                                                                          • Stream pointer is null when operation is unsuccessful Examples:<\/li>\n
                                                                          • if (fobj.is_open()) {\/\/file opened, process} else {\/\/error}<\/li>\n
                                                                          • if (fobj.good()) {\/\/successful operation, process} else {\/\/error}<\/li>\n
                                                                          • If (fobj.fail()) {\/\/error} else {\/\/ successful operation, process}<\/li>\n
                                                                          • If (fobj.bad()) {\/\/error} else {\/\/ successful operation, process}<\/li>\n
                                                                          • If (fobj.eof()) {\/\/error, end of file} else {\/\/ process}<\/li>\n
                                                                          • If (!fobj) {\/\/error} else {\/\/ successful operation, process}<\/li>\n
                                                                          • if (fobj) {\/\/ successful operation, process} else {\/\/error}<\/li>\n<\/ul>\n

                                                                             <\/p>\n

                                                                            Remember that once error bit of error state is set, it remains in effect. When checking error in next operation with associated stream, it will show an error even if next operation is successful. So, do not forget to reset the error state flag associated with the stream after an error is encountered. One may use clear() method to reset the error state associated with stream.<\/p>\n

                                                                             <\/p>\n

                                                                            Examples of working with binary files<\/p>\n

                                                                             <\/p>\n

                                                                            1.3.\u00a0 <\/strong>Program to copy contents of one file to another file using get() and put() methods<\/p>\n

                                                                             <\/p>\n

                                                                              \n
                                                                            • \/\/ copy one file to another using get(), put()<\/li>\n
                                                                            • \/\/ character by character copy<\/li>\n<\/ul>\n

                                                                              #include <iostream><\/p>\n

                                                                              #include<fstream><\/p>\n

                                                                              using namespace std;<\/p>\n

                                                                               <\/p>\n

                                                                              int main()<\/p>\n

                                                                              {<\/p>\n

                                                                              ifstream fin;<\/p>\n

                                                                              fin.open(“file1.pdf”, ios::in | ios::binary);<\/p>\n

                                                                               <\/p>\n

                                                                              ofstream fout;<\/p>\n

                                                                              fout.open(“file2.pdf”, ios::out | ios::binary);<\/p>\n

                                                                              if (! (fin.is_open() && fout.is_open()))<\/p>\n

                                                                              { cout << “Error opening file\u2026”, exit(1); }<\/p>\n

                                                                               <\/p>\n

                                                                              char ch;<\/p>\n

                                                                              while(!fin.eof())<\/p>\n

                                                                              { ch = fin.get(); fout.put(ch); }<\/p>\n

                                                                               <\/p>\n

                                                                              fin.close();\u00a0\u00a0\u00a0 fout.close();<\/p>\n

                                                                              return 0;<\/p>\n

                                                                              }<\/p>\n

                                                                              Before executing this code, see that the location of input file is same as that of the executable program. Otherwise, use full path.<\/p>\n

                                                                               <\/p>\n

                                                                               <\/p>\n

                                                                              1.4. <\/strong>Program to copy entire content of one file at a time to another file using read() and write()<\/p>\n

                                                                               <\/p>\n

                                                                              If a file is small enough to get accommodated in memory, binary copy can be performed by reading and writing entire file at a time using single read and write operation.<\/p>\n

                                                                               <\/p>\n

                                                                              In program code 9.1, do modifications as shown below and then execute.<\/p>\n

                                                                                \n
                                                                              • replace statement<\/li>\n<\/ul>\n

                                                                                fin.open(“file1.pdf”, ios::in | ios::binary); with<\/p>\n

                                                                                 <\/p>\n

                                                                                fin.open(“file1.pdf”, ios::in | ios::binary | ios::ate); \/\/ file pointer at end of file<\/p>\n

                                                                                  \n
                                                                                • replace code<\/li>\n<\/ul>\n

                                                                                  char ch;<\/p>\n

                                                                                  while(!fin.eof())<\/p>\n

                                                                                  {\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ch = fin.get(); fout.put(ch);\u00a0\u00a0\u00a0\u00a0\u00a0 }<\/p>\n

                                                                                   <\/p>\n

                                                                                   <\/p>\n

                                                                                  with following code<\/p>\n

                                                                                   <\/p>\n

                                                                                  streampos size;<\/p>\n

                                                                                  char * buf;<\/p>\n

                                                                                   <\/p>\n

                                                                                  size=fin.tellg(); buf=new char [size]; \/\/ get size of file and allocate memory of size bytes<\/p>\n

                                                                                  if (buf) \/\/ memory allocation successful<\/p>\n

                                                                                  {<\/p>\n

                                                                                   <\/p>\n

                                                                                  fin.seekg (0, ios::beg); \/\/ pointer at beginning of file fin.read (buf, size); fout.write (buf, size);<\/p>\n

                                                                                  }<\/p>\n

                                                                                  else {cout << “error allocating memory”;}<\/p>\n

                                                                                   <\/p>\n

                                                                                   <\/p>\n

                                                                                  Here, input file is opened with ios::ate mode to have file pointer at end. It enables to know the size of file using tellg(); and then memory buffer of that size can be allocated.<\/p>\n

                                                                                   <\/p>\n

                                                                                  Note that the program code size has become larger, but execution will be faster. After all, execution time matters a lot!<\/p>\n

                                                                                   <\/p>\n

                                                                                  1.5. <\/strong>Program to copy one file to another file with one block at a time using read() and write()<\/p>\n

                                                                                  If a file is very large, it may not possible to get enough memory to allocate. It is safer to copy block by block. Block size should be selected to be large enough to reduce number of read\/write operations, but to get successful memory allocation.<\/p>\n

                                                                                   <\/p>\n

                                                                                  Modify program code 9.1 as follows:<\/p>\n

                                                                                   <\/p>\n

                                                                                  replace code<\/p>\n

                                                                                   <\/p>\n

                                                                                  char ch;<\/p>\n

                                                                                  while(!fin.eof())<\/p>\n

                                                                                  {\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0\u00a0 ch = fin.get(); fout.put(ch);\u00a0\u00a0\u00a0\u00a0\u00a0 }<\/p>\n

                                                                                   <\/p>\n

                                                                                   <\/p>\n

                                                                                  with following code<\/p>\n

                                                                                   <\/p>\n

                                                                                  \/\/copy block by block<\/p>\n

                                                                                  streampos size = 4096;<\/p>\n

                                                                                  char buf [4096];<\/p>\n

                                                                                  while (!fin.eof())<\/p>\n

                                                                                   <\/p>\n

                                                                                  { fin.read (buf, size); fout.write (buf, fin.gcount());<\/p>\n

                                                                                  }<\/p>\n

                                                                                   <\/p>\n

                                                                                  1.6.\u00a0 <\/strong>Program to write and read objects in binary file using write() and read() methods<\/p>\n

                                                                                   <\/p>\n

                                                                                  For examples of objects in binary file, consider class Student as shown below:<\/p>\n

                                                                                   <\/p>\n

                                                                                  class Student<\/p>\n

                                                                                  {char name[30];<\/p>\n

                                                                                  int marks[7]; \/\/ marks in 7 subjects<\/p>\n

                                                                                  public:<\/p>\n

                                                                                  void GetStudentData()\u00a0 \/\/ input student data<\/p>\n

                                                                                  {<\/p>\n

                                                                                  cout << “Enter student’s name: “;<\/p>\n

                                                                                  cin.getline(name,30);<\/p>\n

                                                                                  cout << “Enter marks in 7 subjects:”;<\/p>\n

                                                                                  for (int i=0; i<7; i++) cin >> marks[i];<\/p>\n

                                                                                  }<\/p>\n

                                                                                   <\/p>\n

                                                                                  void ShowStudentData() \/\/ display student data<\/p>\n

                                                                                  {<\/p>\n

                                                                                   <\/p>\n

                                                                                  cout << “Name: ” << name <<endl;<\/p>\n

                                                                                  cout << “Marks: “;<\/p>\n

                                                                                  for (int i = 0; i<7; i++) cout << marks[i] << ”\u00a0 “;<\/p>\n

                                                                                  cout << endl;<\/p>\n

                                                                                  }<\/p>\n

                                                                                   <\/p>\n

                                                                                   <\/p>\n

                                                                                  char * getname() { return name; }<\/p>\n

                                                                                  void getMarks ()<\/p>\n

                                                                                  {<\/p>\n

                                                                                  cout << “Enter marks in 7 subjects:”;<\/p>\n

                                                                                  for (int i=0; i<7; i++) cin >> marks[i];<\/p>\n

                                                                                  }<\/p>\n

                                                                                  }; \/\/ end class Student<\/p>\n

                                                                                   <\/p>\n

                                                                                  Refer following code to write objects in binary file, read all objects and display. While<\/p>\n

                                                                                  writing into file, objects are inserted in file at end, so file is to be opened with ios::app<\/p>\n

                                                                                  mode.<\/p>\n

                                                                                  Student sobj;<\/p>\n

                                                                                   <\/p>\n

                                                                                  void writeStudents()<\/p>\n

                                                                                  {<\/p>\n

                                                                                  ofstream outfile;<\/p>\n

                                                                                   <\/p>\n

                                                                                  outfile.open(“student.dat”, ios::out | ios::binary | ios::app); if (!outfile.is_open())<\/p>\n

                                                                                  { cout << “Error opening input file\u2026”, exit(1); }<\/p>\n

                                                                                   <\/p>\n

                                                                                  int i,n;<\/p>\n

                                                                                   <\/p>\n

                                                                                  cout << “How many students to add? “;<\/p>\n

                                                                                  cin >> n;<\/p>\n

                                                                                  for ( i=0; i<n; i++)<\/p>\n

                                                                                  {<\/p>\n

                                                                                  cin.get(); \/\/ extract enter key<\/p>\n

                                                                                   <\/p>\n

                                                                                    \n
                                                                                  • \/\/ read student data GetStudentData();<\/li>\n
                                                                                  • \/\/ write student data in binary file write ( (char*)&sobj, sizeof(sobj));<\/li>\n<\/ul>\n

                                                                                    }<\/p>\n

                                                                                    outfile.close();<\/p>\n

                                                                                    } \/\/ end addStudents<\/p>\n

                                                                                     <\/p>\n

                                                                                    void readStudents()<\/p>\n

                                                                                     <\/p>\n

                                                                                    {<\/p>\n

                                                                                     <\/p>\n

                                                                                    ifstream infile(“student.dat”, ios::in | ios::binary); if (!infile )<\/p>\n

                                                                                    { cout << “Error opening input file\u2026”, exit(2); }<\/p>\n

                                                                                      \n
                                                                                    • \/\/ read from binary file<\/li>\n<\/ul>\n

                                                                                       <\/p>\n

                                                                                      infile.read( (char*)&sobj, sizeof(sobj));<\/p>\n

                                                                                      while (!infile.eof())<\/p>\n

                                                                                       <\/p>\n

                                                                                      {<\/p>\n

                                                                                      \/\/if (infile) \/\/ successful read<\/p>\n

                                                                                      sobj.ShowStudentData();<\/p>\n

                                                                                      infile.read( (char*)&sobj, sizeof(sobj));<\/p>\n

                                                                                      }<\/p>\n

                                                                                      infile.close();<\/p>\n

                                                                                      }<\/p>\n

                                                                                       <\/p>\n

                                                                                      int main()<\/p>\n

                                                                                      {<\/p>\n

                                                                                      writeStudents();<\/p>\n

                                                                                       <\/p>\n

                                                                                      readStudents();<\/p>\n

                                                                                      cout <<“Press any key “;<\/p>\n

                                                                                      cin.get(); cin.get();<\/p>\n

                                                                                      return 0;<\/p>\n

                                                                                      }<\/p>\n

                                                                                       <\/p>\n

                                                                                      Sample output of program is shown below.<\/p>\n

                                                                                       <\/p>\n

                                                                                      How many students to add? 2<\/p>\n

                                                                                      Enter student’s name: Tina<\/p>\n

                                                                                      Enter marks in 7 subjects:45 40 38 47 42 48 39<\/p>\n

                                                                                      Enter student’s name: Ali<\/p>\n

                                                                                      Enter marks in 7 subjects:48 43 40 37 36 47 45<\/p>\n

                                                                                      Name: Tina<\/p>\n

                                                                                       <\/p>\n

                                                                                      Marks: 45\u00a0 40\u00a0 38\u00a0 47\u00a0 42\u00a0 48\u00a0 39<\/p>\n

                                                                                      Name: Ali<\/p>\n

                                                                                      Marks: 48\u00a0 43\u00a0 40\u00a0 37\u00a0 36\u00a0 47\u00a0 45<\/p>\n

                                                                                       <\/p>\n

                                                                                       <\/p>\n

                                                                                      1.6.1. <\/strong>Modify object stored in binary file<\/p>\n

                                                                                       <\/p>\n

                                                                                      Add function to modify marks of a specified student and write updated record back in binary file as shown here.<\/p>\n

                                                                                       <\/p>\n

                                                                                      void modifyMarks()<\/p>\n

                                                                                      {<\/p>\n

                                                                                      \/\/file for read\/write purpose, so use fstream class<\/p>\n

                                                                                      fstream file(“student.dat”, ios::in | ios::out | ios::binary);<\/p>\n

                                                                                      if (!file )<\/p>\n

                                                                                      { cout << “Error opening input file\u2026”, exit(3); }<\/p>\n

                                                                                       <\/p>\n

                                                                                      char name [40];<\/p>\n

                                                                                       <\/p>\n

                                                                                      cout << “Enter name of student to modify marks: “; cin >> name;<\/p>\n

                                                                                       <\/p>\n

                                                                                      file.read( (char*)&sobj, sizeof(sobj));<\/p>\n

                                                                                      while (!file.eof())<\/p>\n

                                                                                      {<\/p>\n

                                                                                      if (strcmp(name, sobj.getname())==0) \/\/ object found<\/p>\n

                                                                                      {<\/p>\n

                                                                                      sobj.getMarks();<\/p>\n

                                                                                       <\/p>\n

                                                                                      long pos = -1 * sizeof(sobj); \/\/for backward move file.seekp (pos, ios::cur); \/\/back from current file.write ((char*)&sobj, sizeof(sobj));<\/p>\n

                                                                                       <\/p>\n

                                                                                      break;<\/p>\n

                                                                                      }<\/p>\n

                                                                                      file.read( (char*)&sobj, sizeof(sobj)); \/\/read next<\/p>\n

                                                                                       <\/p>\n

                                                                                      }<\/p>\n

                                                                                      file.close();<\/p>\n

                                                                                      }<\/p>\n

                                                                                       <\/p>\n

                                                                                       <\/p>\n

                                                                                      Calling modifyMarks() and readstudents() in main function will result in the following output:<\/p>\n

                                                                                       <\/p>\n

                                                                                      Enter name of student to modify marks: Tina<\/p>\n

                                                                                      Enter marks in 7 subjects:45 45 46 46 47 47 40<\/p>\n

                                                                                       <\/p>\n

                                                                                      after modification …<\/p>\n

                                                                                      Name: Tina<\/p>\n

                                                                                      Marks: 45\u00a0 45\u00a0 46\u00a0 46\u00a0 47\u00a0 47\u00a0 40<\/p>\n

                                                                                      Name: Ali<\/p>\n

                                                                                      Marks: 48\u00a0 43\u00a0 40\u00a0 37\u00a0 36\u00a0 47\u00a0 45<\/p>\n

                                                                                       <\/p>\n

                                                                                      Here, observe following points in the code:<\/p>\n

                                                                                       <\/p>\n

                                                                                        \n
                                                                                      • Use of fstream with input as well as output open mode<\/li>\n<\/ul>\n

                                                                                         <\/p>\n

                                                                                        To modify marks of a specified student, it requires reading student, modifying marks if name is matching, and then writing student object back at the same position. Hence, one should use fstream class object for i\/o strem.<\/p>\n

                                                                                         <\/p>\n

                                                                                          \n
                                                                                        • Positioning \u201cput\u201d pointer at the beginning of record before writing<\/li>\n<\/ul>\n

                                                                                           <\/p>\n

                                                                                          After reading an object, file position is moved sizeof(sobj) bytes ahead. Before writing the updated object back, the position of \u201cput\u201d pointer should be moved sizeof(obj) bytes in backward direction.<\/p>\n

                                                                                           <\/p>\n

                                                                                          1.6.2.<\/strong>\u00a0\u00a0\u00a0 Delete an object from binary file<\/p>\n

                                                                                           <\/p>\n

                                                                                          Deletion of record from a file can be implemented using logical deletion or physical deletion.<\/p>\n

                                                                                           <\/p>\n

                                                                                          For logical deletion of an object, add one data member, say delFlag, in a class to mark the object as deleted. Now deletion is as good as modifying object by setting delFlag to true. A care should be taken while processing, like showing only non-deleted objects.<\/p>\n

                                                                                          With physical deletion, an object record is to be removed from file. Due to sequential nature of streams, remaining records are to be shifted. It requires setting \u201cget\u201d and \u201cput\u201d pointer for all remaining records. The simple solution is to write remaining records in one temporary file and copying temporary file back to original file. This can be performed using following steps:<\/p>\n

                                                                                           <\/p>\n

                                                                                          (i) Create temporary file<\/p>\n

                                                                                          (ii) Read an object from data file<\/p>\n

                                                                                          (iii) If it matches with the specified object to be deleted, do not write in temporary file; otherwise write in temporary file<\/p>\n

                                                                                          (iv) Repeat steps (ii) and (iii) till end of data file<\/p>\n

                                                                                          (v) Close both files<\/p>\n

                                                                                          (vi) Delete original data file<\/p>\n

                                                                                          (vii) Rename temporary file as original data file<\/p>\n

                                                                                          (viii) rename(“temp.dat”, “marks.dat”);<\/p>\n

                                                                                           <\/p>\n

                                                                                          Refer following code using physical deletion of records from binary file.<\/p>\n

                                                                                           <\/p>\n

                                                                                          void deleteStudent()<\/p>\n

                                                                                          {<\/p>\n

                                                                                           <\/p>\n

                                                                                          ifstream infile(“student.dat”, ios::in | ios::binary); if (!infile )<\/p>\n

                                                                                          { cout << “Error opening input file\u2026”, exit(2); }<\/p>\n

                                                                                           <\/p>\n

                                                                                          ofstream tmpfile;<\/p>\n

                                                                                           <\/p>\n

                                                                                          tmpfile.open(“temp.dat”, ios::out | ios::binary); \/\/ copy objects in temp file if (!tmpfile.is_open())<\/p>\n

                                                                                           <\/p>\n

                                                                                          { cout << “Error opening input file\u2026”, exit(4); }<\/p>\n

                                                                                           <\/p>\n

                                                                                          char name [40];<\/p>\n

                                                                                           <\/p>\n

                                                                                          cout << “Enter name of student to be deleted: “; cin >> name;<\/p>\n

                                                                                           <\/p>\n

                                                                                          infile.read( (char*)&sobj, sizeof(sobj));<\/p>\n

                                                                                          while (!infile.eof())<\/p>\n

                                                                                          {<\/p>\n

                                                                                          if (strcmp(name, sobj.getname())!=0) \/\/ object not to be deleted<\/p>\n

                                                                                          {<\/p>\n

                                                                                          tmpfile.write ((char*)&sobj, sizeof(sobj));<\/p>\n

                                                                                          }<\/p>\n

                                                                                           <\/p>\n

                                                                                          infile.read( (char*)&sobj, sizeof(sobj)); \/\/read next<\/p>\n

                                                                                          }<\/p>\n

                                                                                          infile.close(); tmpfile.close();<\/p>\n

                                                                                          remove(“student.dat”); \/\/ remove old student.date file<\/p>\n

                                                                                           <\/p>\n

                                                                                          rename(“temp.dat”, “student.dat”); \/\/ rename temp.dat to student.dat<\/p>\n

                                                                                          }<\/p>\n

                                                                                          Write following lines in main() and execute program.<\/p>\n

                                                                                           <\/p>\n

                                                                                          deleteStudent();<\/p>\n

                                                                                          cout << “\\nafter deletion … \\n”;<\/p>\n

                                                                                           <\/p>\n

                                                                                          readStudents();<\/p>\n

                                                                                           <\/p>\n

                                                                                           <\/p>\n

                                                                                          Observe the ouput:<\/p>\n

                                                                                           <\/p>\n

                                                                                          Enter name of student to be deleted: Tina<\/p>\n

                                                                                           <\/p>\n

                                                                                          after deletion …<\/p>\n

                                                                                          Name: Ali<\/p>\n

                                                                                          Marks: 48\u00a0 43\u00a0 40\u00a0 37\u00a0 36\u00a0 47\u00a0 45<\/p>\n

                                                                                           <\/p>\n

                                                                                          1.6.3. Random access: Reading nth object from binary file<\/strong><\/p>\n

                                                                                           <\/p>\n

                                                                                          To access nth object from file without reading previous records, simply position \u201cget\u201d file pointer at (n-1)*sizeof(obj) bytes from beginning of file and read the record as follows.<\/p>\n

                                                                                           <\/p>\n

                                                                                          ifstream file;<\/p>\n

                                                                                          file.open(“student.dat”, ios::in | ios::binary);<\/p>\n

                                                                                          \/\/input n<\/p>\n

                                                                                          long pos = (n-1) * sizeof(sobj); \/\/for moving pos bytes ahead from beginning<\/p>\n

                                                                                          file.seekg (pos);\u00a0 \/\/ from beginning<\/p>\n

                                                                                          file.read ((char*)&sobj, sizeof(sobj));<\/p>\n

                                                                                          sobj.ShowStudentData();<\/p>\n

                                                                                          file.close();<\/p>\n

                                                                                           <\/p>\n

                                                                                           <\/p>\n

                                                                                          Summary<\/strong><\/p>\n

                                                                                            \n
                                                                                          • Binary files are used for persistent storage of data in raw format o No type conversion or formatting takes place<\/li>\n<\/ul>\n

                                                                                            o\u00a0 Data stored in the format as it is stored in main memory<\/p>\n

                                                                                              \n
                                                                                            • Advantages of binary files over text files\n
                                                                                                \n
                                                                                              • o Faster input\/output operations<\/li>\n
                                                                                              • o Storage apace efficient<\/li>\n
                                                                                              • o Not editable using text editors<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n
                                                                                                  \n
                                                                                                • While opening, requires ios::binary open mode to be specified alongwith other modes<\/li>\n
                                                                                                • Input\/output operations can be performed using\n
                                                                                                    \n
                                                                                                  • o Methods read() and write() for any type of data; may be numeric, character,<\/li>\n<\/ul>\n<\/li>\n<\/ul>\n

                                                                                                     <\/p>\n

                                                                                                    string, struct, object etc.<\/p>\n

                                                                                                      \n
                                                                                                    • o Additionally, methods get() and put() can be used to read and write character data<\/li>\n
                                                                                                    • Random access and file error handling is same as with text files<\/li>\n<\/ul>\n

                                                                                                      References<\/strong><\/p>\n

                                                                                                       <\/p>\n

                                                                                                       <\/p>\n

                                                                                                      1) Stanley Lippmann, \u201cC++ Primer\u201d, Pearson Education.<\/p>\n

                                                                                                      2) Bjarne Stroustrup, \u201cThe C++ Programming Language\u201d, Pearson Education.<\/p>\n

                                                                                                      3) Scott Mayer, \u201cEffective C++\u201d, Addison Wesley.<\/p>\n

                                                                                                      4) Bhushan Trivedi , Programming with ANSI C++, 2\/e , Oxford University Press.<\/p>\n

                                                                                                      5) Yashavant P. Kanetkar \u201cLet Us C++\u201d , Bpb Publications.<\/p>\n

                                                                                                      6) Abhiram G. Ranade, \u201cAn Introduction to Programming through C++\u201d , McGraw Hill<\/p>\n

                                                                                                      7) Ellis and B. Stroustrup \u201cAnnotated C++ Reference Manual\u201d, http:\/\/www.stroustrup.com\/arm.html<\/p>\n

                                                                                                      8) Herbert Schildt, \u201cComplete Reference C++\u201d, McGraw Hill Publications.<\/p>\n

                                                                                                      9) Ashok Kamthane, \u201cObject Oriented Programming with ANSI and Turbo C++\u201d, Pearson Education<\/p>\n

                                                                                                      10) E Balaguruswami, \u201cObject Oriented Programming With C++\u201d, Tata McGraw Hill<\/p>\n

                                                                                                      11) \u201cC++ FAQs\u201d, Pearson Education.<\/p>\n

                                                                                                       <\/p>\n","protected":false},"author":4,"menu_order":29,"template":"","meta":{"_acf_changed":false,"pb_show_title":"on","pb_short_title":"","pb_subtitle":"","pb_authors":["dr-jyotika-doshi"],"pb_section_license":""},"chapter-type":[],"contributor":[60],"license":[],"class_list":["post-213","chapter","type-chapter","status-publish","hentry","contributor-dr-jyotika-doshi"],"part":3,"_links":{"self":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters\/213","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters"}],"about":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/types\/chapter"}],"author":[{"embeddable":true,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/users\/4"}],"version-history":[{"count":3,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters\/213\/revisions"}],"predecessor-version":[{"id":294,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters\/213\/revisions\/294"}],"part":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/parts\/3"}],"metadata":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapters\/213\/metadata\/"}],"wp:attachment":[{"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/media?parent=213"}],"wp:term":[{"taxonomy":"chapter-type","embeddable":true,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/pressbooks\/v2\/chapter-type?post=213"},{"taxonomy":"contributor","embeddable":true,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/contributor?post=213"},{"taxonomy":"license","embeddable":true,"href":"https:\/\/ebooks.inflibnet.ac.in\/itp1\/wp-json\/wp\/v2\/license?post=213"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}