Streams and Files#

Complete each of the exercises below using CLion. If you have difficulty writing a program, try writing it in Java or Python first to get an idea of the structure to use. Although most programs written in C will also run in C++, if you are asked to write a program in C++ you are expected to make use of C++‘s features.

Create a new C++ project. Cut and paste the following code.

1
#include <iostream>
2
using namespace std;
3

4
class Rational {
5
private:
6
    int64_t num;
7
    uint64_t denom;
8
public:
9
    Rational()
10
         : num(0), denom(1)
11
    {}
12
    Rational(const Rational &o)
13
        : num(o.num), denom(o.denom)
14
    {}
15
    Rational(int64_t numP, uint64_t denomP)
16
        : num(numP), denom(denomP)
17
    {
18
        if(denomP == 0){
19
            throw std::logic_error("Rational number cannot have a zero denominator");
20
        }
21
    }
22
    int64_t numerator() const {
23
        return num;
24
    }
25
    uint64_t denominator() const {
26
        return denom;
27
    }
28

29
    friend Rational operator*(const Rational&,const Rational&);
30
    friend Rational operator+(const Rational&,const Rational&);
31
};
32
Rational operator*(const Rational& l, const Rational& r){
33
    return Rational( l.num*r.num, l.denom*r.denom );
34
}
35
Rational operator+(const Rational& l, const Rational& r){
36
    return Rational( l.num*r.denom + r.num*l.denom, l.denom*r.denom );
37
}
38
int main() {
39
    Rational a(1,2);
40
    Rational b(2,3);
41
    Rational c = a+b;
42
    Rational d = a*b;
43

44
    cout << a << endl;
45
    cout << b << endl;
46
    cout << c << endl;
47
    cout << d << endl;
48
}

The class represents rational numbers with signed numerator and positive (non-zero) denominator.
Operator overloading allows to use “natural” addition and multiplication.
The friend keyword can be use to give specific non-class-members full access to private data. This is useful for code that semantically/logically belongs to a class, but for syntactic reasons cannot not be in it (may appear in operator overloading).

This code does not yet compile because there is no operator << defined for Rational. Implement it such that the original code compiles and outputs:

1
(1/2)
2
(2/3)
3
(7/6)
4
(2/6)

Create a matching input stream operator >>. Test it by reading a Rational from the cin standard input with

1
Rational e;
2
cin >> e;
3
cout << "input was " << e << endl;

Simple solution:

1
istream& operator>>(istream& is, Rational& r){
2
    char c1, c2, c3;
3
    int64_t rnum;
4
    uint64_t rdenom;
5
    is>>c1>>rnum>>c2>>rdenom>>c3;
6
    r=Rational(rnum, rdenom);
7
    return is;
8
}

In the input operator, test whether the data read actually represents a Rational with the correct formatting. Only write the output parameter r if it does. If not, set the stream’s fail bit so that other parts of the program have a chance of detecting the problem. You can use the following code to test:

1
cout << "input rational number: ";
2
Rational e;
3
cin >> e;
4
if(cin.fail()){
5
    cout << "the input could not be parsed" << endl;
6
    cin.clear(); // clear previous errors
7
}
8
else{
9
    cout << "input was " << e << endl;
10
}

Test for wrong separator characters as well as invalid numbers in between. Are there other relevant test cases?

Now implement a function bool store(list<Rational> l, string filename). It takes a list of numbers and a filename. It must then create a new file with that name, and write all numbers in the list into it. In order to have a human-readable file, separate the numbers with new-lines (one number per line). Return true if the writing was successful, false if not. Create a list to test with and choose a filename. Inspect the generated file in the file browser.
Write a function bool append(Rational r, string filename) that appends a number to the end of an existing file. Again, return true if and only if the output was successful.
Now write a function bool read(string filename, list<Rational> &list) that reads a list of numbers from a file. The file with the given name is supposed to be opened and values filled into the list given in the second parameter. Again, return true only if everything was correct. The file should be in the format as written by store. However, write a method that is robust (e.g. does not crash or give wrong values) to missing files, wrongly formatted files and the like. In order to check whether individual numbers have been read correctly, check whether the operator operator>>(istream& is, Rational& r), if used, set the failbit.

参考答案：

1
//
2
// Created by 不死鸟Anka on 2025/11/24.
3
//
4
#include <iostream>
5
#include <list>
6
#include <string>
7
#include <fstream>
8
#include <sstream>
9
using namespace std;
10

11
class Rational {
12
private:
13
    int64_t num; //分子
14
    uint64_t denom; //分母
15
public:
16
    Rational() // default constructor
17
         : num(0), denom(1)
18
    {}
19
    Rational(const Rational &o) // copy constructor
20
        : num(o.num), denom(o.denom)
21
    {}
22
    Rational(int64_t numP, uint64_t denomP) // parameterized constructor
23
        : num(numP), denom(denomP)
24
    {
25
        if(denomP == 0){
26
            throw std::logic_error("Rational number cannot have a zero denominator");
27
            // 处理分母为零的情况
28
        }
29
    }
30
    int64_t numerator() const {
31
        return num;
32
    }
33
    uint64_t denominator() const {
34
        return denom;
35
    }
36

37
    // friend 允许非成员函数访问类的私有成员
38
    friend Rational operator*(const Rational&,const Rational&);
39
    friend Rational operator+(const Rational&,const Rational&);
40
    // Add output operator
41
    friend std::ostream& operator<<(std::ostream&, const Rational&);
42
    // Add input operator
43
    friend std::istream& operator>>(std::istream&, Rational&);
44
};
45
Rational operator*(const Rational& l, const Rational& r){ // 两个参数：左操作数和右操作数
46
    return Rational( l.num*r.num, l.denom*r.denom );
47
}
48
Rational operator+(const Rational& l, const Rational& r){
49
    return Rational( l.num*r.denom + r.num*l.denom, l.denom*r.denom );
50
}
51
// Implement output operator
52
std::ostream& operator<<(std::ostream& os, const Rational& r) {
53
    os << "(" << r.numerator() << "/" << r.denominator() << ")";
54
    return os;
55
}
56
// Implement input operator: accepts optional surrounding parentheses, format: num/denom
57
std::istream& operator>>(std::istream& is, Rational& r) {
58
    // use sentry to handle skipws and locale stuff
59
    std::istream::sentry s(is);
60
    if (!s) return is;
61

62
    // parse into local temporaries so we only modify 'r' on success
63
    std::streampos startPos = is.tellg(); // may return -1 for some streams, but we won't rely on it
64

65
    is >> std::ws; // skip leading whitespace
66
    bool has_paren = false;
67
    // peek()函数
68
    // 其调用形式为cin.peek()，返回值是一个char类型的字符，其返回值是指向指向的当前字符，如果要访问的字符是文件结束符，则函数值是EOF(-1)。
69
    // 但只是做观测使用，即指针仍停留在当前位置，并不后移。其功能是从输入流中读取一个字符，但该字符并未从输入流中删除。
70
    if (is.peek() == '(') {
71
        is.get(); // consume '('
72
        has_paren = true;
73
        is >> std::ws;
74
    }
75

76
    int64_t num_val = 0;
77
    if (!(is >> num_val)) {
78
        is.setstate(std::ios::failbit);
79
        return is;
80
    }
81

82
    is >> std::ws;
83
    char sep = 0;
84
    if (!(is >> sep) || sep != '/') {
85
        is.setstate(std::ios::failbit);
86
        return is;
87
    }
88

89
    // read denominator as signed so we can detect negative values (which are invalid here)
90
    int64_t denom_signed = 0;
91
    if (!(is >> denom_signed)) {
92
        is.setstate(std::ios::failbit);
93
        return is;
94
    }
95

96
    if (denom_signed <= 0) {
97
        // invalid denominator (zero or negative)
98
        is.setstate(std::ios::failbit);
99
        return is;
100
    }
101

102
    is >> std::ws;
103
    if (has_paren) {
104
        char closing = 0;
105
        if (!(is >> closing) || closing != ')') {
106
            is.setstate(std::ios::failbit);
107
            return is;
108
        }
109
    }
110

111
    // all checks passed — assign to output parameter
112
    r.num = num_val;
113
    r.denom = static_cast<uint64_t>(denom_signed);
114
    return is;
115
}
116

117
// Store a list of Rationals to a file, one per line. Return true on success, false on failure.
118
bool store(list<Rational> l, string filename) {
119
    std::ofstream ofs(filename, std::ios::out | std::ios::trunc);
120
    if (!ofs.is_open() || !ofs.good()) {
121
        return false;
122
    }
123
    for (const Rational &x : l) {
124
        ofs << x << '\n';
125
        if (!ofs.good()) {
126
            return false;
127
        }
128
    }
129
    ofs.close();
130
    return ofs.good();
131
}
132

133
// Append a Rational to the end of an existing file. Return true iff write succeeded.
134
bool append(Rational r, string filename) {
135
    std::ofstream ofs(filename, std::ios::out | std::ios::app); // 设置为追加模式（app）
136
    if (!ofs.is_open() || !ofs.good()) {
137
        return false;
138
    }
139
    ofs << r << '\n';
140
    if (!ofs.good()) {
141
        return false;
142
    }
143
    ofs.close();
144
    return ofs.good();
145
}
146

147
// Read a list of Rationals from a file. Fill the provided list only if the whole file is valid.
148
// Return true iff every non-empty line contains exactly one valid Rational and the file could be opened/read.
149
bool read(string filename, list<Rational> &outList) {
150
    std::ifstream ifs(filename);
151
    if (!ifs.is_open() || !ifs.good()) {
152
        return false;
153
    }
154

155
    std::list<Rational> temp;
156
    std::string line;
157
    size_t lineNo = 0;
158
    while (std::getline(ifs, line)) {
159
        ++lineNo;
160
        // skip lines that are empty or contain only whitespace
161
        bool all_ws = true;
162
        for (char ch : line) if (!std::isspace(static_cast<unsigned char>(ch))) { all_ws = false; break; }
163
        if (all_ws) continue;
164

165
        std::istringstream iss(line);
166
        // use sentry behavior of streams via operator>>; operator>> will set failbit on malformed input
167
        Rational r;
168
        iss >> r;
169
        if (iss.fail()) {
170
            // malformed rational on this line
171
            return false;
172
        }
173
        // after successful extraction, there must be only whitespace left
174
        iss >> std::ws;
175
        if (!iss.eof()) {
176
            // trailing garbage after the rational
177
            return false;
178
        }
179
        temp.push_back(r);
180
    }
181

182
    ifs.close();
183

184
    if (ifs.bad()) {
185
        // I/O error
186
        return false;
187
    }
188

189
    // all good — assign to output parameter
190
    outList = std::move(temp);
191
    return true;
192
}
193

194
int main() {
195
    Rational a(1,2);
196
    Rational b(2,3);
197
    Rational c = a+b;
198
    Rational d = a*b;
199

200
    cout << a << endl;
201
    cout << b << endl;
202
    cout << c << endl;
203
    cout << d << endl;
204

205
    cout << "input rational number: ";
206
    Rational e;
207
    cin >> e;
208
    if(cin.fail()){
209
        cout << "the input could not be parsed" << endl;
210
        cin.clear(); // clear previous errors
211
    }
212
    else{
213
        cout << "input was " << e << endl;
214
    }
215

216
    // Test the store function: create a list and write to a file
217
    list<Rational> nums;
218
    nums.push_back(a);
219
    nums.push_back(b);
220
    nums.push_back(c);
221
    nums.push_back(d);
222

223
    string outFile = "/Users/anka/Desktop/CPP/Week9/rationals_output.txt";
224
    bool ok = store(nums, outFile);
225
    cout << "store returned: " << (ok ? "true" : "false") << " -> " << outFile << endl;
226

227
    // Test append: add one more Rational to the same file
228
    Rational extra(3,5);
229
    bool appOk = append(extra, outFile);
230
    cout << "append returned: " << (appOk ? "true" : "false") << " -> " << outFile << endl;
231

232
    // Show file contents to verify
233
    cout << "file contents after append:" << endl;
234
    std::ifstream ifs(outFile);
235
    string line;
236
    while (std::getline(ifs, line)) {
237
        cout << line << endl;
238
    }
239
    ifs.close();
240

241
    // Now test the read function to read back the file into a new list
242
    list<Rational> readBack;
243
    bool readOk = read(outFile, readBack);
244
    cout << "read returned: " << (readOk ? "true" : "false") << " -> " << outFile << endl;
245
    if (readOk) {
246
        cout << "values read:" << endl;
247
        for (const auto &rr : readBack) cout << rr << endl;
248
    }
249

250
    // Additional robustness tests
251
    // 1) malformed file: contains a bad line in the middle
252
    string badFile = "/Users/anka/Desktop/CPP/Week9/rationals_bad.txt";
253
    {
254
        std::ofstream ofs(badFile, std::ios::out | std::ios::trunc);
255
        ofs << "(1/2)\n";
256
        ofs << "this_is_not_a_rational\n";
257
        ofs << "(3/4)\n";
258
    }
259
    list<Rational> tmp;
260
    bool badOk = read(badFile, tmp);
261
    cout << "read malformed file returned: " << (badOk ? "true" : "false") << " -> " << badFile << endl;
262

263
    // 2) missing file
264
    string missingFile = "/Users/anka/Desktop/CPP/Week9/this_file_does_not_exist.txt";
265
    list<Rational> tmp2;
266
    bool missingOk = read(missingFile, tmp2);
267
    cout << "read missing file returned: " << (missingOk ? "true" : "false") << " -> " << missingFile << endl;
268

269
    return 0;
270
}

Hi~ I'm Anka!

Streams and Files#