Object Oriented Programming using C++: Ch12 Streams and Files.pptx

Stream Classes
 A stream is a general name given to a flow of data.
 In C++ a stream is represented by an object of a particular class. So far we’ve
used the cin and cout stream objects.
 Different streams are used to represent different kinds of data flow. For
example, the ifstream class represents data flow from input disk files.
Advantages of Streams
 One reason is simplicity. Another reason is that you can overload existing
operators and functions, such as the insertion (<<) and extraction (>>)
operators, to work with classes that you create.
 You should know about C++ streams because they are the best way to write
data to files and to format data in memory for later use in text input/output
windows and other GUI elements.
[2]

The Stream Class Hierarchy
[3]

[4]

 ios class is the base class for the hierarchy. It contains many constants and
member functions common to input and output operations, such as the
showpoint and fixed formatting flags
 The ios class also contains a pointer to the streambuf class, which contains the
actual memory buffer into which data is read or written.
 The istream and ostream classes are derived from ios and are dedicated to
input and output, respectively.
 The istream class contains such functions as get(), getline(), read(), and the
 overloaded extraction (>>) operators, while ostream contains put() and
write(), and the overloaded insertion (<<) operators.
 The iostream class is derived from both istream and ostream by multiple
inheritance. Classes derived from it can be used with devices, such as disk
files, that may be opened for both input and output at the same time. [5]

 Three classes istream_withassign, ostream_withassign, and
iostream_withassign are inherited from istream, ostream, and iostream,
respectively. They add assignment operators to these classes.
 The cout object, is a predefined object of the ostream_withassign class
 Similarly, the cin is an object of the istream_withassign class
 The classes used for input and output to the video display and keyboard are
declared in the header file IOSTREAM.
 The classes used specifically for disk file I/O are declared in the file FSTREAM.
[6]

Disk File I/O with Streams
 Most programs need to save data to disk files and read it back in. Working
with disk files requires another set of classes:
 ifstream for input
 fstream for both input and output
 and ofstream for output.
 Objects of these classes can be associated with disk files, and we can use their
member functions to read and write to the files.
 These three classes are declared in the FSTREAM file.
[7]

Formatted File I/O
 In formatted I/O, numbers are stored on disk as a series of characters. Thus
6.02, rather than being stored as a 4-byte type float or an 8-byte type double,
is stored as the characters ‘6’, ‘.’, ‘0’, and ‘2’.
 This can be inefficient for numbers with many digits, but it’s appropriate in
many situations and easy to implement.
[8]

// writes formatted output to a file
// using << operator
#include <fstream> // for file I/O
#include <iostream>
#include <string>
#include <stdlib.h>
using namespace std;
int main()
{
char ch = 'x';
int j = 77;
double d = 6.02;
// strings without embedded spaces
string str1 = "Rashid";
string str2 = "Farid";
// create ofstream object
ofstream outfile("data.txt");
9
Example 1: Writing Data to a File
outfile << ch // insert (write) data
<< j
<< ' ' // needs space between numbers
<< d
<< str1
<< ' ' //needs spaces between strings
<< str2;
cout << "File writtenn";
system("pause");
return 0;
}
1 2
[9]

 If the file doesn’t exist, it is created. If it does exist, it is truncated and the new data
replaces the old.
 The outfile object acts much as cout did in previous programs, so we can use the insertion
operator (<<) to output variables of any basic type to the file.
 This works because the insertion operator is appropriately overloaded in ostream, from
which ofstream is derived.
 When the program terminates, the outfile object goes out of scope. This calls its destructor,
which closes the file, so we don’t need to close the file explicitly
 There are several potential formatting glitches. First, you must separate numbers (such as
77 and 6.02) with nonnumeric characters.
 As numbers are stored as a sequence of characters, this is the only way the extraction
operator will know, when the data is read back from the file, where one number stops and
the next one begins.
[10]

 Second, strings must be separated with whitespace for the same reason. This
implies that strings cannot contain imbedded blanks.
 In this example we use the space character (‘ ‘) for both kinds of delimiters.
Characters need no delimiters, since they have a fixed length.
 You can verify that program has indeed written the data by examining the
DATA.TXT file with the Windows NOTEPAD accessory or the DOS command
TYPE.
[11]

// reads formatted output from a file
// using >> operator
#include <iostream>
#include <string>
#include <stdlib.h>
int main() {
char ch;
int j;
double d;
string str1, str2;
// create ifstream object
ifstream infile("data.txt");
//extract (read) data from it
infile >> ch
>> j
>> d
>> str1
>> str2;
12
Example 2: Reading Data from a File
cout << ch << endl // display the data
<< j << endl
<< d << endl
<< str1 << endl
<< str2 << endl;
system("pause");
return 0;
}
1 2
[12]

 If you’ve ever used MS-DOS, you are
probably familiar with command-line
arguments, used when invoking a
program. They are typically used to
pass the name of a data file to an
application. For example, you can
invoke a word processor application
and the document it will work on at the
same time:
 C>wordproc afile.doc
 Here afile.doc is a command-line
argument. How can we get a C++
program to read the command-line
arguments? Here’s an example
13
Example 3: Command-Line Arguments
#include <iostream>
int main(int argc, char* argv[] ) {
// number of arguments
cout << "argc = " << argc << endl;
// display arguments
for(int j=0; j<argc; j++)
cout << "Argument " << j << " = "
<< argv[j] << endl;
return 0;
}
[13]

Command-Line Arguments
 And here’s a sample interaction with the program:
 To read command-line arguments, the main() function (don’t forget it’s a function!) must
itself be given two arguments. The first, argc (for argument count), represents the total
number of command-line arguments. The first command-line argument is always the
pathname of the current program. The remaining command-line arguments are those
typed by the user; they are delimited by the space character. In the preceding example they
are uno, dos, and tres.
[14]

#include <fstream> // for file
#include <iostream>
#include <process.h> //for exit()
int main(int argc, char* argv[] ) {
if( argc != 2 ) {
cerr << "Format: oop filename"
<< endl;
exit(-1);
}
char ch; //character to read
ifstream infile; // to read a file
infile.open( argv[1] );// open file
15
Example 4: Command-Line Arguments
if( !infile ) { // check for errors
cerr << "nCan't open "
<< argv[1];
exit(-1);
}
while( infile.get(ch) != 0 ) //read a character
cout << ch; //display the character
return 0;
}
1 2
[15]

Strings with Embedded Blanks
 The technique of our last examples won’t work with char* strings containing
embedded blanks.
 To handle such strings, you need to write a specific delimiter character after
each string, and use the getline()function, rather than the extraction
operator, to read them in.
 Our next program, outputs some strings with blanks embedded in them.
[16]

// file output with strings
#include <iostream>
#include <stdlib.h>
int main() {
// create file for output
//send text to file
outfile << "I fear thee, ancient!n";
outfile << "I fear thy skinny handn";
outfile << "And thou art long brown,n";
system("pause");
return 0;
}
17
Example 5, 6: Writing and Reading String in a File
// file input with strings
#include <iostream>
#include <stdlib.h>
int main() {
const int MAX = 80; // size of buffer
char buffer[MAX]; // character buffer
// create file for input
while (!infile.eof()){ // until end-of-file
// read a line of text
infile.getline(buffer, MAX);
// display it
cout << buffer << endl;
}
system("pause");
return 0;
}
1 2
[17]

Writing and Reading String in a File
 This program requires all the text lines to terminate with the ‘n’ character, and if you
encounter a file in which this is not the case, the program will hang.
 The program continues to read one string at a time until it encounters an end-of-file (EOF)
condition. The EOF is a signal sent to the program from the operating system when there is
no more data to read.
 However, checking specifically for an eofbit means that we won’t detect the other error
flags, such as the failbit and badbit, which may also occur, although more rarely. To do this,
we can change our loop condition:
while (infile.good()){ // until any error encountered
 You can also test the stream directly. If everything is going well, the object infile returns a
nonzero value which is a pointer. Thus we can rewrite our while loop again:
while (infile){ // until any error encountered
[18]

// file output with characters
#include <iostream>
#include <stdlib.h>
int main() {
string str = "Time is a great teacher,"
" but unfortunately it kills all its"
" pupils. Berlioz";
for (unsigned int j = 0;
j < str.size(); j++)
// write it to file
outfile.put(str[j]);
cout << "File writtenn";
system("pause");
return 0;
}
19
Example 7, 8: Character I/O
// file input with characters
#include <iostream>
#include <stdlib.h>
int main() {
char ch; // character to read
// read until the EOF is reached
// or an error occurs
while (infile){
infile.get(ch);
// read a character
cout << ch; // display it
}
cout << endl;
system("pause");
return 0;
}
1 2
[19]

Binary I/O
 You can write a few numbers to disk using formatted I/O, but if you’re storing
a large amount of numerical data it’s more efficient to use binary I/O, in which
numbers are stored as they are in the computer’s RAM memory, rather than
as strings of characters.
 In binary I/O an int is stored in 4 bytes, whereas its text version might be
“12345”, requiring 5 bytes. Similarly, a float is always stored in 4 bytes, while
its formatted version might be “6.02314e13”, requiring 10 bytes.
 example shows how an array of integers is written to disk and then read back
into memory, using binary format.
 We use write(), a member of ofstream; and read(), a member of ifstream.
 These functions think about data in terms of bytes (type char). They don’t care
how the data is formatted, they simply transfer a buffer full of bytes from and
to a disk file. [20]

// binary input and output with integers
#include <fstream> //for file streams
#include <iostream>
#include <stdlib.h>
const int MAX = 100; //size of buffer
int buff[MAX]; //buffer for integers
int main() {
int i;
for (i = 0; i < MAX; i++) // fill buffer with data { 0, 1, 2, ... ,99}
buff[i] = i;
ofstream os("numbers.txt", ios::binary); // create output stream
os.write((char*)buff, MAX * sizeof(int)); // write to it
os.close(); // must close it
for (i =0; i < MAX; i++) // erase buffer
buff[i] = 0;
ifstream is("numbers.txt", ios::binary); // create input stream
is.read((char*)buff, MAX * sizeof(int)); // read from it
Example 9: Binary I/O with integers (1/2)
[21]

for (i = 0; i < MAX; i++) // check data
if (buff[i] != i){
cerr << i<< " Data is incorrectn";
return 1;
}
cout << "Data is correctn";
system("pause");
return 0;
}
Example 9: Binary I/O with integers (2/2)
[22]

Object I/O
 Since C++ is an object-oriented language, it’s reasonable to wonder how
objects can be written to and read from disk.
 The next examples show the process
 When writing an object, we generally want to use binary mode. This writes
the same bit configuration to disk that was stored in memory, and ensures
that numerical data contained in objects is handled properly.
 Here’s the listing for OPERS, which asks the user for information about an
object of class person, and then writes this object to the disk file PERSON.DAT
[23]

#include <fstream> // for file streams
#include <iostream>
class person { // class of persons
protected:
char name[80]; // person’s name
short age; // person’s age
public:
void getData() { //get person’s data
cout << "Enter name : "; cin.get(name,80);
cout << "Enter age : " ; cin >> age;
}
};
int main() {
person pr1; // create a person
pr1.getData(); // get data for person 1
ofstream outfile("PERSON.DAT", ios::binary); // create ofstream object
outfile.write((char*) &pr1, sizeof(pr1)); // write to it
return 0;
}
Example 10: Writing Object to a File
[24]

// saves person object to disk
#include <iostream>
class person {
protected:
char name[80]; // person’s name
short age; // person’s age
public:
void showData() { // display person’s data
cout << "Name: " << name << endl;
cout << "Age : " << age << endl;
}
};
int main() {
person pr1; // create a person
ifstream infile("PERSON.DAT", ios::binary);
infile.read((char*) &pr1, sizeof(pr1)); // read from file
pr1.showData(); return 0;
}
Example 10: Reading Object from a File
[25]

istream Functions
[26]
Function Purpose
>> Formatted extraction for all basic (and overloaded) types.
get(ch) Extract one character into ch.
getline(str, MAX) Extract one line into array str, until MAX characters or the ‘n’ character
getline(str, MAX, DELIM) Extract characters into array str, until MAX characters or the DELIM character.
putback(ch) Insert last character read back into input stream.
ignore(MAX, ‘n’) Extract and discard up to MAX characters until (and including) the specified delimiter ‘n’.
ch = stream.peek( ) Read one character, leave it in stream.
read(str, MAX) For files, extract up to MAX characters into str, until EOF.
seekg(n) Set distance (n bytes) of file pointer from start of file. e.g.
infile.seekg(0, ios::end); // go to 0 bytes from end
seekg(pos, seek_dir) Set distance (in bytes) of file pointer from specified place in file. seek_dir can be ios::beg,
ios::cur, ios::end.
tellg( ) Return position (in bytes) of file pointer from start of file. e.g. int endposition = infile.tellg();

ostream Functions
[27]
Function Purpose
<< Formatted insertion for all basic (and overloaded) types.
put(ch) Insert one character ch into stream.
flush() Flush buffer contents and Insert newline.
write(str, SIZE) Insert SIZE characters from array str into file.
seekp(n) Set distance in n bytes of file pointer from start of file.
seekp(pos, seek_dir) Set distance (in bytes) of file pointer from specified place in file. seek_dir can be ios::beg,
ios::cur, ios::end.
tellgp( ) Return position (in bytes) of file pointer from start of file. e.g. int endposition = outfile.tellg();

#include <iostream>
class Book
{
protected:
char title[80];
char auther[80];
double price;
public:
void Add_Record();
void Read_All();
void Search();
void Delete();
};
Example 11: Books Management System (1/8)
[28]

void Book::Add_Record() {
cout << "Enter title : ";
// eat chars, including newline
cin.ignore(80, 'n');
cin.getline(title, 80);
cout << "Enter Auther : ";
cin.getline(auther, 80);
cout << "Enter Price : ";
cin >> price;
cout << "Title = " << title << endl;
cout << "Auther = " << auther << endl;
cout << "Price = " << price << endl;
ofstream outfile;
outfile.open("books.txt", std::ios_base::app);
outfile << title << "" << auther << "" << price << endl;
system("pause");
}
[29]

void Book::Read_All() {
system("CLS");
const int MAX = 240; int S_No = 0;
ifstream infile("books.txt");
while (infile) {
if (strlen(buffer) > 0) {
const char* delim = "";
char* next_token;
char* title = strtok_s(buffer, delim, &next_token);
char* auther = strtok_s(NULL, delim, &next_token);
char* prc = strtok_s(NULL, delim, &next_token);
cout << "#" << ++S_No << endl;
cout << " Title = " << title << endl;
cout << " Auther = " << auther << endl;
cout << " Price = " << prc << endl;
}
}
}
[30]

void Book::Search() {
int S_No = 0;
cout << "Enter title to Search: ";
// eat chars, including newline
cin.ignore(80, 'n');
cin.getline(this->title, 80);
system("CLS");
while (infile) {
char* next_token;
char* output = strstr(title, this->title);
[31]

S_No++;
if (output) {
cout << "#" << S_No << endl;
cout << "Title = " << title << endl;
cout << "Auther = " << auther << endl;
cout << "Price = " << prc << endl;
cout << "_________________________________" << endl;
}
}
}
}
void Book::Delete() {
system("CLS");
int R_No = 0, S_No = 0;
cout << "Please Enter Record Number: ";
cin >> R_No;
ofstream outfile("temp.txt");
[32]

while (infile) {
char* next_token;
S_No++;
if (S_No == R_No) {
char choice;
cout << "#" << S_No << endl;
cout << " Title = " << title << endl;
cout << " Auther = " << auther << endl;
cout << " Price = " << prc << endl;
cout << "Do you want to Delete this Record [y/n]?: ";
cin >> choice;
if (choice == 'y')
continue;
[33]

else
outfile << title << "" << auther << "" << prc << endl;
}
else
outfile << title << "" << auther << "" << prc << endl;
}
}
infile.close();
outfile.close();
remove("books.txt");
rename("temp.txt", "books.txt");
}
int main() {
Book b;
while (1) {
char choice;
cout << "[Operations]" << endl;
cout << "A - Add" << endl;
cout << "D - Delete" << endl;
[34]

cout << "R - Read All" << endl;
cout << "S - Search Title" << endl;
cout << "Q - Quit " << endl;
cin >> choice;
switch (choice) {
case 'A':
case 'a': b.Add_Record(); break;
case 'D':
case 'd': b.Delete(); break;
case 'R':
case 'r': b.Read_All(); break;
case 'S':
case 's': b.Search(); break;
case 'Q':
case 'q': exit(0);
default: cout << "Wrong Choice" << endl;
}
}
return 0;
}
[35]

Object Oriented Programming using C++: Ch12 Streams and Files.pptx

Recommended

More Related Content

Similar to Object Oriented Programming using C++: Ch12 Streams and Files.pptx (20)

More from RashidFaridChishti (20)

Recently uploaded (20)

Object Oriented Programming using C++: Ch12 Streams and Files.pptx