如何仅使用标准库将 C++ 对象写入文件

Question

I'll start by clarifying what makes this question not a dupe:

• Anything that is outside the standard C++ library is is banned, that includes boost and the other libraries
• The objects may contain malloc -ed C-style arrays

Before flagging this question as a dupe, please provide a question where these 2 requirements are addressed.

Before flagging this question as not useful, please consider that writing objects with bad data members may be a legitimate requirement for my upcoming C++ test in college. I've seen some tests for the previous years, where it was stated that a class BankAccount for example must have 2 dynamically allocated double * . As to why only use the standard library, I'm afraid it's quite likely our teacher doesn't know how to use boost, or anything except std.

I have tried this code, which unfortunately doesn't work quite right:

#include<fstream>
#include<iostream>

using namespace std;

class Student
{
    int roll;
    char name[25];
    float marks;
    int *arr;
    double *second;
public:
    friend ostream& operator<<(ostream& out, const Student &s)
    {
        out << s.marks << s.name << s.roll;
        for (int i = 0; i < 5; ++i) {
            out << s.arr[i];
        }
        for (int i = 0; i < 10; ++i) {
            out << s.second[i];
        }
        out << std::endl;
        return out;
    }
    friend istream& operator>>(istream& ins, Student &s)
    {
        ins >> s.marks >> s.name >> s.roll;
        for (int i = 0; i < 5; ++i) {
            ins >> s.arr[i];
        }
        for (int i = 0; i < 10; ++i) {
            ins >> s.second[i];
        }
        return ins;
    }

    Student() : roll(10), name("Platon"), marks(4)
    {
        arr = new int[5];
        second = new double[10];
        for (int i = 0; i < 5; ++i) {
            arr[i] = i + 1;
        }
        for (int j = 0; j < 10; ++j) {
            second[j] = j + 1;
        }
    }
    Student(int r, char n[25], float m, int* a, double* s): roll(r), marks(m)
    {
        arr = new int[5], second = new double[10];
        for (int i = 0; i < 25; ++i) {
            name[i] = n[i];
        }
        for (int j = 0; j < 5; ++j) {
            arr[j] = a[j];
        }
        for (int k = 0; k < 10; ++k) {
            second[k] = s[k];
        }
    }
};

int main()
{
    int dummy[] = {1, 2, 3, 4, 5};
    double another[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
    ofstream fp("file.bin", ofstream::out|ofstream::binary);
    Student S(56, "Platon Makovsky", 14.2, dummy, another);
    cout << "writing: "; cout << S << std::endl;
    fp << S;
    fp.close();
    Student test;
    ifstream f("file.bin", ifstream::in|ifstream::binary);
    f >> test;
    cout << "read: "; cout << test << std::endl;
    f.close();

    return 0;
}

This program generates this output:

writing: 14.2Platon Makovsky561234512345678910

read: 14.2Platon01234512345678910

For some reason the program failed to read the complete name and the roll. Any help with this problem is appreciated.

Btw I know about using namespace std; , I just didn't feel like writing std:: all the time. The destructor has been omitted for the sake of brevity, I know about memory management too.

Answer 1

Okay, there are reasons why there are formal definitions of file formats like XML and JSON. You're hitting it.

You need some means of determining where individual fields start and end. Imagine, for instance, that you decide to put each field on its own line. This is perfectly legitimate. Write them out, one per line, and when you read them back, read lines from the file and convert to the proper data type. Easy.

Until you put out a string with a newline in it. Now that value is spanning two lines, which you probably didn't consider.

So I would write a function that converts strings to "safe strings". Specifically, convert every instance of newline to literally the characters \n. While at it, convert a single \ to two \. Imagine this string:

This is foo\bar.
And it had a newline.

This would get turned into:

This is foo\\bar.\nAnd it had a newline.

(Literally -- that's not a newline, that's a string representation you can recognize as a newline.)

Then write the reverse function. It converts \ into a single \ and \n into a proper newline again.

That's step one.

Step two: decide how you're going to indicate a field is null. You could just write null. That will work for numeric fields, but if you do that, what are you going to do about char * that's null? You can still write null, but what if your value is literally the text null? Decide how you want to represent this. You could have pointers be something like "value=12345" or "value=abcde", and then null could just be "null". That would be safe.

Step three: write your fields, one per line. Use this safe string method when writing strings, and do whatever you're going to do about pointers.

Step four: write a method that reads the file one line at a time and just print it out (so you know it works).

Step five: use this to produce your new object (reading from the file).

if you do this correctly, you should be able to handle all the basic data types.

It might take you an hour or two.