1. File I/O ifstreams and ofstreams Sections 11.1 & 11.2 1

2. Introduction Up to now we have been: getting input from the keyboard via cin sending output to the screen via cout and cerr We now see how to: get input from a text file send output to a text file 2

3. Problem 3 data1.txt 80 97 93.5 72 65.8... 68.3 Project 9 Using OCD, design and implement a program that computes the average of a sequence of numbers stored in a file.

4. Program Preliminary Analysis Using #include, a program can read from the keyboard via the istream named cin, but this is of little benefit when the data we need is in a file. What we need is a way to somehow establish an istream-like connection between our program and the input file, such that we can then read from the file via that connection. 4 data1.txt 80 97 93.5 72 65.8... 68.3

5. Behavior Our program should display its purpose and then display a prompt for the name of the input file, which it should then read. Our program should open a connection from itself to that input file. It should then read the numbers from the input file via the connection, and compute their sum and count. It should then close the connection, and compute and display the average of the numbers. 5 80 97 93.5 72 65.8... 68.3 Program data1.txt

6. Objects Description Type Kind Name purpose, prompt string constant (none) file name string varying inFileName connection ??varying fin a number double varying number sum double varying sum count double varying count average double varying average 6

7. Operations Description Library? Name display a string string<< read a string stringgetline() open a connection ???? to a file read numbers via ???? connection sum & count numbers built-in +=, ++, loop close connection ???? compute average built-in / display average iostream<< 7 or >> if no blanks in filenames

8. Algorithm 8 0. Display purpose of program, and prompt for input file name. 1. Read name of input file from cin into inFileName. 2. Open connection named fin to file named in inFileName. 3. Initialize sum, count to zero. 4. Loop: a. Try to read a value from fin into number. b. If no values were left, terminate repetition. c. Add number to sum. d. Increment count. End loop. 5. Close fin. 6. If count > 0 a. Compute average = sum / count. b. Display count and average with appropriate labels Else display error message. a. Try to read a value from cin into number. b. If no values are left, terminate repetition. 0. Display purpose of program

9. Implementation in C++ To establish connections to an file, the library provides file-stream types: the ifstream class for input streams the ofstream class for output streams The programmer uses these types to declare file-stream objects; for example, ifstream fin; ofstream fout; 9

10. To connect such fstream objects to files: Method 1: Use the open() function member in these classes: ifstream fin; fin.open("name of file"); ofstream fout; fout.open("name of file"); Method 2: Use initializing declarations: ifstream fin("name of file"); ofstream fout("name of file"); 10

11. Disadvantage of "hard-wiring" actual file names into a program: the program must be modified when using a different file. A better alternative: Have user enter the file name and store it in a string variable; for example, string inFileName; cout << "Enter name of file: "; getline(cin, inFileName); When attaching an fstream to this file, we must use string 's data() (or c_str() ) function member to extract the actual file name stored in the string object; for example, ifstream fin(infileName.data()); Similar declarations are used for output streams. 11 or use >> if no blanks in filenames

12. How to read from / write to a file connected to an fstream: Input: Use >> just like from an istream ; fin >> var; Output: Use << just like from an ostream ; fout << expr; 12 or getline() Note: For output, we can use any of the format manipulators such as endl, fixed, setprecison(), and setw() ifstream inherits everything from istream ofstream " " " ostream

13. 13 When we are finished with a file — both for input and output files — we should break the connection between it and the program. Although this will happen automatically when the connection reaches the end of its scope, it is a good idea to do this explicitly with the fstream's function member close() ; for example, fin.close(); fout.close();

14. Objects Description Type Kind Name purpose, prompt string constant (none) file name string varying inFileName connection ifstream varying fin a number double varying number sum double varying sum count double varying count average double varying average 14

15. Operations Description Library Name display a string string<< read a string stringgetline() open a connection fstream declaration to a file of fstream (or open() ) read numbers via fstream >> connection sum & count numbers built-in +=, ++, loop close connection fstream close() compute average built-in / display average iostream<< or >> 15

16. Two More Problems: 1.Opening a file for input can fail. Solution: Use the ifstream function member is_open(). ifstream fin(infileName.data()); assert(fin.is_open()); 16 2.How do we know when all the data in the file has been read? The ifstream function member eof() returns true if an attempted read found no data remaining in the file. Must try to read and fail In Visual C++: create the file in Visual C++ and "Add to" project. Must be in same folder as program.cpp and the.vcproj put in Resources folder

17. Coding /*------------------------------------------------------------- Program to read data values from a text file, count them, and find their average. Input(keyboard): Name of the file Input(file): doubles Output(screen): Prompts, average of the data value with labels, or file-empty message -------------------------------------------------------------*/ #include // cin, cout,... #include // ifstream, ofstream,... #include // string #include // assert() using namespace std; int main() { cout << "\nTo average the numbers in an input file," << "\nenter the name of the file: "; string inFileName; getline(cin, inFileName); 17 Note

18. ifstream fin ( inFileName );.data() 18 OR: ifstream fin; fin.open( infileName.data() ); assert(fin.is_open()); // verify it opened double number, sum = 0.0; // variables for int count = 0; // computing average for (;;) // input loop { _______________ // read number if __________ // if none were left, quit sum += number; // add it to sum count++; // bump up count } // end loop // open the connection fin >> number; (fin.eof()) break; cin >> number; (number == -999) break; fin.close(); // close fstream

19. 19 if (count > 0) { double average = sum / count; cout << "\nThe average of the values in " << inFileName << " is " << average << endl; } else cout << "\n*** No values found in file " << inFileName << endl; }

20. Testing To test our program, we use a text editor and create some easy-to-check input files such as 10 20 30 40 If we name this particular file test1.txt and enter its name when prompted by our program, the average value produced should be 25. 20 Create text files in Visual C++

21. Continue testing using other input files, trying to find places where our program breaks down. And it is is important to try various kinds of files — ascending order, descending order, random order, files with 1 element, empty files... — because programs that work for some of these may fail for others. 21 To average the numbers in an input file, enter the name of the file: test1.txt The average of the values in test1.txt is 25 E.G., Project 9

22. Once we are confident that our program is correct, we can execute it with the data file from our problem: 22 To average the numbers in an input file, enter the name of the file: data1.txt The average of the values in test1.txt is 80.1 data1.txt 80 97 93.5 72 65.8... 68.3

23. Key Things to Remember The fstream library defines two classes: ifstream, for creating connections between programs and input files; and ofstream, for creating connections between programs and output files. Both ifstream and ofstream objects are created in a similar fashion. 23

24. If inFileName contains the name of an input file, and outFileName contains the name of an output file, then the statements ifstream fin(inFileName.data()); ofstream fout(outFileName.data()); define fin and fout as connections to them. Note that the string function member data() (or c_str() ) must be used to retrieve the actual char- acters of the file’s name from the file stream object. 24 or: ifstream fin; fin.open(inFileName.data()); or: ofstream fout; fout.open(outFileName.data());

25. If a program tries to open an ifstream to a file that doesn’t exist, the open is said to fail. To check whether or not an ifstream is open, the ifstream class provides the is_open() function member, which returns true if the ifstream was successfully opened, and false if it not. Whether or not a file opened correctly should always be verified using is_open(). 25 assert(fin.is_open()); or assert(!fin.fail()); or use an if

26. Important Notes About Output Files: If a program tries to open an ofstream to a file that doesn’t exist or that can't be found, the open operation creates a new empty file for output. If a program tries to open an ofstream to a file that does exist, the open operation (by default) empties that file of its contents, creating a clean file for output. 26 Destroys it! Be careful! To open an existing file for output without emptying it, the value ios::app can be given as a second argument: ofstream fout(outFileName.data(), ios::app); Output will be appended to whatever is already in the file.

27. For rare occasions where a file is needed for both input and output, the fstream class is provided: fstream fInOut(ioFileName.data(), ios::in | ios::out); This statement defines an fstream named fInOut to a file, from which data can be read, and to which data can be written. The bitwise OR operator ( | ) is used to combine file open-modes in this manner. 27

28. Summary  #include to use file streams.  To establish a connection to a file whose name is given by a string variable fileName : For input: ifstream fin(fileName.data()); or: ifstream fin; fin.open(fileName.data()) For output: ofstream fout(fileName.data()); or: ofstream fout; fout.open(fileName.data()) 28 fileName Note: data() (or c_str() ) must be used to retrieve the actual characters of the file’s name from fileName.

29.  To check whether or not an ifstream is open: assert(fin.is_open()); or assert(!fin.fail()); (or use an if statement) 29  Once an ifstream (or ofstream) has been opened, it can be read from (or written to) using the usual input (or output) operations: input: >>, get(), getline(),... output: <<, put(),... In general, anything that can be done to an istream (or ostream) can be done to an ifstream (or ofstream).

30.  The eof() function member provides a convenient way to build input loops: for (;;) { fin >> someValue; if (fin.eof()) break; //... process someValue }  Remember that opening a file for output erases any contents in the file. 30

31.  Once we are done using an ifstream (or ofstream), it should be closed using the close() function member: fin.close(); fout.close(); Most systems limit the number of files a program can have open simultaneously, so it is a good practice to close a stream when finished with it.  A closed file can be (re)opened using open() : fin.open(inFileName.data()); fout.open(outFileName.data()); 31