Introduction To Object-Oriented Programming COMP2011: File I/O

Introduction to
Object-Oriented Programming
COMP2011: File I/O
Prof. Andrew Horner

Dr. Cecia Chan
Dr. Cindy Li
Department of Computer Science & Engineering

The Hong Kong University of Science and Technology
Hong Kong SAR, China
developed by Prof. Brian Mak
{horner, kccecia, lixin}@cse.ust.hk COMP2011 (Spring 2018) p.1

C++ Stream
Up to now, you only know how to interactively

input data from the keyboard using cin
output data to the screen using cout
In general, C++ allows you to

input/output data to/from files
and devices (e.g. printer, hard
disk, USB memory stick) using
an abstraction called stream.

C++ Stream
C++ Stream
A stream is simply a sequence of characters.
The data transferred between a C++ program and a

file/device are modeled as a stream of characters, regardless
of the data type (basic types: int, float, etc.; user-defined
types: btree, linked list, etc.).
A device can also be treated like a file. In the following, when

we say file, we mean both file and device.

Stream I/O Operations ,
To perform I/O, create a stream object (from various stream

classes) for each file.
These stream objects all support the 2 basic input/output
operators: , .
Both and are implemented so that they convert
input/output data of the required type from/to a sequence of
characters.
The input operator always skip whitespaces — spaces, tabs,
newlines, formfeeds, carriage returns — before reading the
next datum.

Common Stream Member Functions
The stream objects of various stream classes also support the
following class member functions:
open(const char* filename): create a stream and associate it
with a file with the given filename.
close( ): close a stream created by open( ).
eof( ): check if the end of a file is reached.
get(char& c): get the next character into the variable c from
an input stream.
getline(char* s, int max-num-char, char terminator=’\n’): get
a stream of characters and put it into the char array pointed
by the variable s. getline( ) stops when either
(max-num-char - 1) characters are read; or,
the stopping character terminator (’\n’ by default) is seen.
Notice that the stopping character is not read into the array,
and the null character is automatically inserted at the end of s.
put(char c): put the character represented by the variable c
onto an output stream.
Interactive Stream: iostream
Stream Type Class Name Header Filename

input stream istream istream
output stream ostream ostream
The header file “iostream” combines the 2 header files

“istream” and “ostream”.
C++ already creates the following istream/ostream objects
for you:
istream cin : standard (or console) input, by default, is the
keyboard.
ostream cout : standard (or console) output, by default, is
the screen.
ostream cerr : standard (or console) error output, by default,
is the screen. From now on, you should send
your error messages to cerr instead of cout.
File Stream: fstream
Stream Type Class Name

input file stream ifstream
output file stream ofstream
The header file “fstream” contains the definitions of 2 classes:

“ifstream” and “ofstream”.
The input file must exist before you create an input file
stream for it.
If the output file doesn’t exist when you create its output file
stream, it will be created for you. If it already exists, its
content will be erased, and overwritten by the new output
data.

Open and Close a File Stream
Create an input file stream from a file called “input.txt” and
an output file stream associated with a file called “output.txt”
by one of the following 2 ways:
Example: Open a File Stream
#include <fstream>
// [1] Use a special form of ifstream/ofstream constructor
ifstream ifs("input.txt");
ofstream ofs("output.txt");
// [2] Use the default form of ifstream/ofstream constructor,

// and then their open() member function
ifstream ifs; ifs.open("input.txt");
ofstream ofs; ofs.open("output.txt");
Close a file stream by

Example: Close a File Stream
ifs.close();
ofs.close();
Example: File Copy
#include <iostream> /* File: filecopy.cpp */
#include <fstream>
using namespace std;
int main()
{
char ip_file[32], op_file[32]; // Input and output filename
cout << "Enter the input filename: "; cin >> ip_file;
ifstream ifs(ip_file); // One way to create a fstream object
if (!ifs)
{ cerr << "Error: Can't open \"" << ip_file << "\"\n"; return -1; }
cout << "Enter the output filename: "; cin >> op_file;
ofstream ofs; ofs.open(op_file); // Another way to create a fstream object
if (!ofs)
{ cerr << "Error: Can't open \"" << op_file << "\"\n"; return -1; }
char c; ifs.get(c); // Try to get the first char

while (!ifs.eof()) // Check if EOF is reached
{
ofs.put(c); // Copy one char at a time
ifs.get(c); // Try to get the next char
}
ifs.close(); ofs.close(); return 0; // Close input/output file streams
}
Example: Read an Array of Integers
#include <iostream> /* File: read-int-array.cpp */

#include <fstream>
using namespace std;
/* Expected input file format:

* array size on the first line, followed by the array elements.
*/
int main()
{
const int MAX_SIZE = 128;
int x[MAX_SIZE]; // An integer array
char ip_file[32]; // Input filename
// Open the file to read

cout << "Enter the input filename: "; cin >> ip_file;
ifstream ifs(ip_file); // One way to create a fstream object
if (!ifs)
{ cerr << "Error: Can't open \"" << ip_file << "\"\n"; return -1; }

Example: Read an Array of Integers ..
int array_size; ifs >> array_size;
if (array_size > MAX_SIZE)
{
cerr << "Error: array size (" << array_size
<< ") > max size of array (" << MAX_SIZE << ")\n";
return -1;
}
// Read in the array

for (int j = 0; j < array_size; j++)
ifs >> x[j];
// Print the array to screen

for (int j = 0; j < array_size; j++)
cout << x[j] << endl;
ifs.close( ); // Close input file stream

return 0;
}

Introduction To Object-Oriented Programming COMP2011: File I/O

Uploaded by

Copyright:

Available Formats

Introduction To Object-Oriented Programming COMP2011: File I/O

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Introduction To Object-Oriented Programming COMP2011: File I/O

Uploaded by

Copyright:

Available Formats

Introduction to

COMP2011: File I/O

Prof. Andrew Horner

Department of Computer Science & Engineering

developed by Prof. Brian Mak

{horner, kccecia, lixin}@cse.ust.hk COMP2011 (Spring 2018) p.1

Up to now, you only know how to interactively

In general, C++ allows you to

{horner, kccecia, lixin}@cse.ust.hk COMP2011 (Spring 2018) p.2

The data transferred between a C++ program and a

A device can also be treated like a file. In the following, when

{horner, kccecia, lixin}@cse.ust.hk COMP2011 (Spring 2018) p.3

To perform I/O, create a stream object (from various stream

{horner, kccecia, lixin}@cse.ust.hk COMP2011 (Spring 2018) p.4

Stream Type Class Name Header Filename

The header file “iostream” combines the 2 header files

Stream Type Class Name

The header file “fstream” contains the definitions of 2 classes:

{horner, kccecia, lixin}@cse.ust.hk COMP2011 (Spring 2018) p.7

// [2] Use the default form of ifstream/ofstream constructor,

Close a file stream by

char c; ifs.get(c); // Try to get the first char

#include <iostream> /* File: read-int-array.cpp */

/* Expected input file format:

// Open the file to read

{horner, kccecia, lixin}@cse.ust.hk COMP2011 (Spring 2018) p.10

// Read in the array

// Print the array to screen

ifs.close( ); // Close input file stream

{horner, kccecia, lixin}@cse.ust.hk COMP2011 (Spring 2018) p.11

You might also like