File IO Stream Objects You have been introduced

File I/O

Stream Objects You have been introduced to these stream objects … l l cin – the standard input stream - an object of the istream class, cout – the standard output stream – an object of the ostream class These streams are automatically created for you when your program executes. To use them you only need to #include <iostream> and the appropriate using directives.

To do file I/O, we will use a new set of stream classes ifstream – objects of this class represent file input ofstream – objects of this class represent file output

File I/O When a program takes input from a file, we say that it reads from the file. When a program puts data into a file, we say that it writes to the file. To read or write to a file, we create a stream object, and connect it to the file.

Text Files Data in a file can either be text or binary. Everything in a text file appears as readable characters. You can look at the file with a text editor, such as notepad. Text files are sometimes referred to as Formatted files. This semester we will only deal with text files.

The fstream classes We use objects of the ifstream class to read from a file, and objects of the ofstream class to write to a file. These classes are defined in <fstream>. To use them we must write #include <fstream>

ifstream Operations >> get ( ) getline( ) ignore( ) stream extraction operator extract one character read a line of data into a string skip a character these ought to look familiar, they are the same functions we use on standard In and standard Out.

Example Code ifstream file. Data (“c: \thefile. txt”); char a; string s; int n; a = file. Data. get( ); file. Data. ignore( ); getline(file. Data, s); file. Data >> n; // pass over newline

Declaring A Stream To use a stream object, it must first be declared ifstream in. Stream; ofstream out. Stream;

Stream variables A stream object is like any other variable, but there are some important exceptions: You cannot assign a value to a stream variable If you pass a stream variable as a parameter, you must pass it by reference.

Connecting a Stream to a File ifstream input. Stream; input. Stream. open (“the. Data. txt”); to program input. Stream the. Data. txt Widget 123 V 89001 12. 95 The preferred method for opening a file is to supply the path when the stream object is created, like this ifstream input. Stream (“the. Data. txt”);

Paths ifstream input. Stream; input. Stream. open (“the. Data. txt”); if no path is specified, the file is assumed to be in the same directory as the program that is executing. When you code a in a pathname, you must write \. Why? input. Stream. open (“c: \the. Data. txt”);

More on Paths and Visual C++ Express You need the file in here when testing your code from the Console. If this is the folder for your project You need the file here when testing your code within C++ Visual Express Edition

Reading From a Text File To read data from a text file, use the stream extraction operator, just as you would use it to read from the keyboard. string description; string part. Number; double price; // no spaces ifstream input. Stream; input. Stream. open (“the. Data. txt”); … input. Stream >> description >> part. Number >> price; …

Reading From a Text File If the data contains spaces, e. g. a person’s name then you must use the getline function from <string> string name; ifstream input. Stream; input. Stream. open (“the. Data. txt”); … getline(input. Stream, name); …

Type Safe I/O In the C programming language, input and output are done with very different libraries than those used in C++ (Although you can still use the C I/O libraries in C++ if you want to). One of the advantages to using the new C++ libraries is that C++ I/O is typesafe. The << and >> operators are overloaded to do the correct thing for all of the standard data types. These operators can also be overloaded for user defined data types.

in the file, this is character data. input. Stream the. Data. txt Widget 123 V 89001 12. 95 double price; input. Stream >> price; Data is read from the file and converted into the appropriate data type. price convert from … 111000011010… character to double

Writing to a Text File Use the stream insertion operator to write to a text file, just as if you were writing to the display. ofstream output. Stream; output. Stream. open (“the. Data. txt”); … output. Stream << price;

Opening an Output file If the named file does not exist, the file is created. If the named file already exists, it is opened, and the contents of the file are discarded, by default.

Formatting the Output Most of the time, when we write data to a file, it is with the idea in mind that the data will be read in from this or some other program. It is up to the programmer to format the data in the output file, so that it can later be read in a meaningful way.

Example int a = 5; int b = 15; int c = 239; ofstream my. Output. Stream (“mydata. txt”); my. Output. Stream << a << b << c; 515239 What happens when you try to read this file?

int a = 5; int b = 15; int c = 239; ofstream my. Output. Stream (“mydata. txt”); my. Output. Stream << a << “ “ << b << “ “ << c; add white space to separate the fields!

Closing the File It is good programming practice to close a file as soon as you are done using it. my. Output. Stream. close ( ); Although a file is closed automatically when a program ends normally, it is not closed if an error occurs and the program terminates abnormally. If the file is not closed, all of the data written to the file is lost!

Mode Bits When a file is opened, you can supply bits that further define the file. These mode bits are defined in the ios class. The ios class contains a number of important constants we use in file I/O. ios: : in ios: : out ios: : app ios: : trunc open the file for reading, the default for ifstream open the file for writing, the default for ofstream open the file for appending. All data is written at the end of the file open the file and discard contents, the default for ofstream ios: : binary open the file for binary content, Note there is no ios: : text which is the default

Example #include <fstream> using std: : ofstream; using std: : ios; ofstream my. Output. Stream (“The. Data. txt”, ios: : app); …

Stream States Objects of all of the stream classes have a state that expresses the condition of the stream. . The stream classes provide functions to query the stream’s state. good( ) eof( ) fail( ) bad( ) Everything’s fine An input operation tried to read beyond the end of the file An input operation failed to read the expected character, or an output operation failed to generate the desired characters Indicates the loss of integrity of the underlying input or output sequence

Checking that a File Opened In C++, errors are not reported unless the programmer explicitly asks. For example, your program could call for a file to be opened and then read data from the file. If the file does not exist, no error is reported and you think that everything worked fine!

ifstream my. Input. Stream; my. Input. Stream. open (“some. Data. txt”); if (my. Input. Stream. fail( )) { cout << “Could not open file”; } else { … check the state of the stream here… We could also write if (!my. Input. Stream) {

Because I/O is subject to so many errors, it is good programming practice to check the state of the stream after every I/O operation!

Writing a loop that reads until end of file

try to open the file did it open ? yes is the end of file flag set ? no no print an error message and quit

is the eof flag set ? yes continue with the rest of your program no read a piece of data was the read good ? yes no was the eof flag set ? no process the data display an error message and quit

We can read and test the state of the stream using the expression while (my. File >> the. Data)

the. File. open("c: \the. File 02. txt"); while (the. File >> the. Data) { cout << "n. Successfully read in the value " << the. Data; } // dropped out, so read failed, see if it is eof or an error if (!the. File. eof( ) ) { cout << "n. Could not read an integer - bad data in the file. "; } else { cout << "n. Reached the end of the file. "; }

File Names as Input string file. Name; cout << “Enter in a file name: “; cin >> file. Name; ifstream my. Data (file. Name); …

Formatting Flags Formatting flags are defined in the ios class. Stream classes have a member function, setf( flag ) that sets these formatting flags. left right dec hex oct showpoint scientific fixed left align output right align output as decimal output as hexadecimal output as octal (base 8) show decimal point on output in exponential format output in fixed format (not scientific) not set set not set not set

You can combine flags with the | operator my. Stream. setf (ios: : fixed | ios: : showpoint); A flag remains set until it is unset. my. Stream. unsetf (ios: : fixed);

Stream Manipulators Stream manipulators go directly into the stream. They are inserted using the stream insertion operator dec hex oct endl setw (w) setprecision (n); setiosflags (flags); setfill (fill. Char); my. Stream << setw (5) << the. Data;

Side Effects You don’t want a function to have an unwanted side effect. One example would be setting I/O flags in a function and leaving them that way when you exit the function. The function flags returns a long data type that contains the settings of all of the I/O flags. long my. Flags = my. Stream. flags ( ); … without an argument the function returns the flags. my. Stream. flags (my. Flags); with an argument, the flags are restored to those set in the parameter.

File Pointers Streams have pointers associated with them get pointer put pointer points to the place next character will be read from points to where the next character will be written tellg( ) tellp ( ) returns current get pointer returns current put pointer seekg ( ) seekp ( ) positions get pointer positions put pointer

seekp (15); move 15 bytes from start of file seekp (-10, ios: : end); move -10 bytes from end of file seekg (6, ios: : cur); move 6 bytes from current position

Binary I/O We will not do any binary I/O in this course. Data is written to the output device exactly as it Is stored in memory. Binary I/O is done with the functions * read( ) * write( ) The parameters are the address of the data buffer and the number of bytes to read or write. The address must be cast to a char*

Persistence We say that a class has persistence when it is possible for an object of that class to exist outside of the life of the program. We accomplish this by having the object save itself (i. e. its data) to a file, and then make it so the object can read itself (its data) back in from a file.