Streams contd. Text: Chapter12, Big C++

Size: px

Start display at page:

Download "Streams contd. Text: Chapter12, Big C++"

Claribel Angelica Edwards
5 years ago
Views:

1 Streams contd Text: Chapter12, Big C++

2 Streams Objects are Abstracted Wrapper around input/output source/destinations Steps in reading/writing streams- Open: Establish connection between object and physical data source/destination Close: disconnects object from physical data source/destination Read/write operations: <<, >>, and some more

3 Parameters to open method Open method takes two parameters, and does not return anythingvoid open (filename, openmode); Filename is const char*, while openmode is one of the enumerated modes from: ios::in, ios::out, ios::app, ios::binary Can be combined using bitwise operator OR: For example, if we want to open the file "example.bin" in binary mode to add data we could do it asofstream file; file.open("example.bin", ios::out ios::app ios::binary);

4 Parameters to open method Classes, have default open mode- ofstream ios::out ios::trunc ifstream ios::in fstream ios::in ios::out

5 Streams While Reading and Writing, stream object maintains current read/write pointer of the stream For input stream, initial read pointer is set in the beginning of the file; file is expected to exist; if does not open fails For output, file is erased (if exists) and pointer is set to beginning, if does not exist, new file is created For append, pointer is set at end of the file

6 Read/Write operations Read/write operation will advance the pointer for the number of character/byte read/written If pointer is moved forward through read/write operations only, then it is sequential read/write If you can directly position the pointer at some location back/forth, then it is called random access Further Read/write takes place from the new pointer position

7 Error state In real life, read/write operations do not always succeed. Might fail for both physical or logical reasons. File not found while opening for input/append Read could not succeed because of bad data format End of file has occurred A disk is full while outputting, or so Streams classes provide certain operation to check for error state. All these functions return true/falsefail(): if last operation has failed eof(): if end of file has occurred good(): no error has occurred on the stream

8 Example: int n; cin >> n; if (!cin.fail() ) Error state // n has read successfully You may find following usage for checking fail: cin >> n; if ( cin ) // n has read successfully Or if (cin >> n ) // n has read successfully

9 Random Access

10 Random Access Each disk file has two special positions: The get position indicates the next read operation starts reading input at the location. The put position indicates where to write the next output. Normally the get position starts at the beginning of the file and is moved towards the end. Initial put position will depend on open mode of the file, typically write takes place at the end. By moving the get and put positions, you can achieve random access.

11 Random Access The following calls move the get and put positions to character n counted from the beginning of the file fs. fs.seekg(n, ios::beg); fs.seekp(n, ios::beg); The second argument can be ios:end or ios::cur to move the position n characters away from the end of the file or the current position, respectively. To determine the current position of the get and put positions (counted from the beginning of the file), use n = fs.tellg(); n = fs.tellp();

12 Random Access Because the files can be very larger, the positions are long integers. To find out the number of characters in a file, move the get position to the end and then find out the distance from the beginning of the file. fs.seekg(0, ios::end); long file_length = fs.tellg();

13 Issue in random access Files requires to be of fixed length Reasons- Editing: If you want to edit salary of an employee from to 36,397.50, will take more space in text file, and this typically would overwrite data of next filed/employee Searching: you can not really randomly position read/write pointer unless you can calculate characters/bytes to be skipped to locate record to be read/written

14 When manipulating data with random access, we have to pay special attention to the formatting of the data. Example: Suppose we store the data as text: Then raise Harry's salary by 5.5 percent to $36, The update overwrites some characters in the next field. In order to be able to update a file, we must give each filed a fixed size that is sufficiently large. As a result, every record in the file has the same size, making it easy to jump over records.

15 Example: We will restructure our records above to Name: 30 characters Salary: 10 characters

20 Binary Files Normally random access is performed on binary files. Binary representation helps in having fixed length record file, as primitive data has fixed size representation, helps in having random access Read/write in binary format becomes more efficient block-wise read/write of raw data

21 Binary Files Recall that << >> are used in case of text files only; For reading writing binary files you have read and write methods functions read/write as stream of bytes

23 Another example reading writing bin file

24 Application Example Database of Employees Have a fixed record length binary file containing, all employees Employee ID, maps to a record number no in the disk file. Allows you to add/edit/search/view an employee record And so,

25 Command Line Arguments Starting a program by typing the name of the program at a prompt in a terminal or shell window is called invoking the program from the command line. When you use this method, you can also type in additional information, called command line arguments, that the program can use. prog -v input.dat Only console programs receive command line arguments

26 To receive command line arguments, you need to define the main function in a different way. int main(int argc, char* argv[]) {... } Here, argc is the count of arguments, and argv contains the values of the arguments. Note that argc is an array of pointers to C character arrays. In the invocation above, argc is 3 and argv contains (pointers to) the strings argv[0]:"prog argv[1]:"-v argv[2]:"input.dat" Note that argv[0] always points to the name of the program and that argc is always at least 1.

27 Command Line Arguments You can modify our previous copy program such that you can use copy program as below at command promptcopy abc.txt xyz.txt

28 Thanks

After going through this lesson, you would be able to: store data in a file. access data record by record from the file. move pointer within the file

After going through this lesson, you would be able to: store data in a file. access data record by record from the file. move pointer within the file 16 Files 16.1 Introduction At times it is required to store data on hard disk or floppy disk in some application program. The data is stored in these devices using the concept of file. 16.2 Objectives