- Reading and writing binary (unformatted) data
is the most simplest thing that you can do with a computer
And this service is provided by the Operating System
- The Operating System
is a huge computer program that manages the resources
available in the computer system
One of the resources is disk space and it is part of the job of an Operating System to provide ways for the programmer to read and write bytes (raw data) from and to disk (files)
- The disk input/output (I/O) services in UNIX is provided through System Calls
- As you may have guess by now, there is nothing in the computer
that is not managed by storing some information about the object
being managed.
- At the Operating System level, when the
Operating System manages an opened file,
the Operating System also manage a data structure
that stores information about the opened file(s).
- But unlike the file pointer management by the
C library, the file data structure managed
by the Operating System is accessed through
an ordinary integer (it's known as a
file identifeer)
- NOTE: make sure you include the necessary header files that define the variable function prototypes and constants (such as the constant O_RDONLY)
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int fd; // file identifier
fd = open("filename", O_RDONLY);
better:
if ( (fd = open("filename", O_RDONLY) ) == -1 )
{
cout << "Error: can't open file" << endl;
exit(1);
}
|
- Meaning of the parameters:
- fd file descriptor returned by open()
- MemoryAddress address of the variable used to receive the data read
- NBytes number of bytes to be read (bytes are read in without any processing; i.e., verbatim....)
- NOTE:
the read() system call will
return the
actual number of bytes read.
This number is usually equal to NBytes,
but it can be less (when the end of file is reached).
- Example Program:
(Demo sequential reading of binary data) ---
click here
#include <unistd.h> int n; n = read(fd, MemoryAddress, NBytes) |
- The most common way to use output file is to collect results.
Use the O_TRUNC mode if you want to truncate an existing file and overwrite it with new data.
Use the O_APPEND mode if you want to append data to an existing file.
There is also a O_RDWR mode that is used in database application where existing data is updated (read and write permitted) - I don't think numerical analysts will ever use this mode and omit it from the discussion...
- The funny value 0644 is the
permission bits of a file and these bits
are only used when the file is actually created (does not exist).
Using 0644 will create a file that is Read/Write for owner, and Read Only for everyone else...
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
int fd;
fd = open("filename", O_WRONLY|O_CREAT|O_TRUNC, 0644);
// Overwrites file
fd = open("filename", O_WRONLY|O_CREAT|O_APPEND, 0644);
// Appends to file
better:
if ( (fd = open("filename", MODE) ) == -1 )
{
cout << "Error: can't create file" << endl;
exit(1);
}
|
- After you finish writing a file, you must close
the file to avoid possible data loss due to system loss of your data
#include <unistd.h> close(fd);
- Meaning of the parameters:
- fd file descriptor returned by open()
- MemoryAddress address of the variable from which the data is written
- NBytes number of bytes to be written (bytes are written without any processing; i.e., verbatim....)
- NOTE:
the write() system call will
also return the
actual number of bytes written.
This number is usually equal to NBytes,
but it can be less (when there is no more
disk space....)
- Example Program:
(Demo writing of unformatted data - overwrite) ---
click here
- Example Program:
(Demo writing of unformatted data - append) ---
click here
write(fd, MemoryAddress, NBytes); |
- offset
the new file position.
(This exact location of the new position depends on
whence)
- whence
can be one of the following values:
SEEK_SET
The new position is equal to offset bytes from the beginning of the file SEEK_CUR
The new position is equal to offset bytes from the current read position in the file SEEK_END
The new position is equal to offset bytes from the end of the file - lseek() returns -1 when an error occurs; otherwise, it returns the new file position relative from the beginning of the file.
- Example Program:
(Demo random reading of formatted data) ---
click here
#include <sys/types.h> #include <unistd.h> int offset; offset = lseek(int fildes, off_t offset, int whence); |
- Binary (unformatted) file I/O is most useful when you save
data that will be used by
another program;
Binary outputs are not useful to save data that is intended for human consumption --- unless your hobby is decoding binary representation
- The following example illustrates where binary output canbe useful:
- Here is an example of a program that print 9 integers into a file
"matrix":
- Here is another program that read 9 integers from a file
"matrix" into a matrix variable A[][]:
The first program uses the binary file "matrix" to transfer information to another program...
- Here is an example of a program that print 9 integers into a file
"matrix":
- Try to print the "matrix" file; you will see garbage.
Do an octal dump on the file with "od -x matrix" and you will see the binary representation of the integers.