Study Guide 14: Streams (File I/O) Answers

b
- ifstream
- ofstream
- fstream
ofstream salefile("SALES.JUN");
a
- ifstreams are for input, ofstreams for output, and fstreams, are for both.
Either of
- fileOut.put(ch);
- fileOut << ch;
a or c. Let os and f be ostream and float variables, respectively:
- os << f;
- os.write(f, sizeof(float));
a
friend istream& operator>> (istream&, Sample&);
b
c
Computers store data in files as a sequence of bytes without meaning beyond their numerical value. Programs give deeper meaning to data by how they use it. C and C++ were developed on Unix, the original POSIX operating system. POSIX systems terminate the lines in text files with a newline character, which programs use to process text files by lines. However, Windows terminates the lines in text files with a two-character sequence: a carriage return and a newline or line feed. Consequently, programs written for one line-terminating protocol will fail when run on a system using the other protocol. So, the short answer is, "To make it easier to port or move programs between POSIX and Windows systems." The following two answers expand on how binary mode operates.
In text mode, file read operations convert carriage return newline sequences to a single newline and write operations convert a newline to a carriage return newline sequence. Text mode, the default, allows programs that process files by lines to work on both Windows and POSIX systems without modification. However, some files (e.g., images, audio, or video) contain numeric data that is not organized by lines, making the conversions inappropriate. In binary mode, no conversions occur, leaving the data intact and unchanged.
None. File I/O operations do not modify the data, leaving its interpretation to the processing program. POSIX systems accept but ignore binary mode when opening a file.
c
- ios is a base class for most of the C++ IO streams, providing access to the named bitmasks. A program opens and reads a file with an ifstream (input file stream); the constructor opens the file in text mode by default. fstream objects allow reading from and writing to a file. iostream objects allow programs to perform console (screen/keyboard) IO.
a
- ofstream (output file stream) objects allow programs to write data to files. By default, the constructor opens the file in text mode, so the program must override the default behavior by specifying the mode with the binary flag. fstream objects allow reading from and writing to a file. iostream objects allow programs to perform console (screen/keyboard) IO.
c or d
- The fstream constructor provides a default value for the mode argument, ios::in | ios::out, making its explicit inclusion unnecessary. However, the file must exist before the fstream constructor runs.
d
- While the fstream constructor provides a default value for the mode argument, ios::in | ios::out, the program must specify the binary flag to open the file in binary mode, replacing the default value. Consequently, the program must specify all three flags to satisfy the problem requirements. Furthermore, the file must exist before the program attempts to open it.
The current working directory or CWD is the location in the file system that the operating system assigns to a program or process when running it. To the program, it "looks like" its position in the file system. The program uses this location for every relative file access it makes.
The current working directory.
The parent of, or one level up from, the current working directory.
a, c, f, & g
b, c, d, f, g, h, & i
a
- b reads the file one character at a time, but loops one time too often. The get function call returning the last character in the file succeeds, so it doesn't set the eof flag. The eof function call (inside the loop control) returns false, which the negation operator converts to true, causing the loop to run again. Statement a combines the read and test together in the loop control, with the test following the read.

ifstream in("data.txt");
if (!in.good()) . . .
	or
if (in.fail()) . . .

Either of

fstream out("data.txt", ios:: binary | ios::app);

ofstream out;
out.open("data.txt", ios::binary | ios::app);

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main()
{
    ifstream in("input.txt");

    if (!in.good())
    {
        cerr << "Unable to open " << input << endl;
        exit(1);
    }

    ofstream out("output.txt");

    if (!out.good())
    {
        cerr << "Unable to open " << output << endl;
        exit(1);
    }

    int c;

    while ((c = in.get()) != EOF)
        switch(c)
        {
            case 'a':
                out << 'A';
                break;
            default:
                out << (char)c;
                break;
        }

    // alternate
    /*while ((c = in.get()) != EOF)
        if (c == 'a')
            out << 'A';
        else
            out << (char)c;*/

    return 0;
}

The variable and while loop can also be written as:

char c;
while (in.get(c))