Question

我正在阅读C ++中的Thinking，并找到了这段代码：

//: C06:Persist1.cpp
// Simple persistence with MI

#include <iostream>
#include <fstream>
using namespace std;
class Persistent {
    int objSize; // Size of stored object
    public:
    Persistent(int sz) : objSize(sz) {}
    void write(ostream& out) const {
    out.write((char*)this, objSize);
    }
    void read(istream& in) {
        in.read((char*)this, objSize);
    }
};
class Data {
    float f[3];
    public:
    Data(float f0 = 0.0, float f1 = 0.0,
        float f2 = 0.0) {
        f[0] = f0;
        f[1] = f1;
        f[2] = f2;
    }
    void print(const char* msg = "") const {
        if(*msg) cout << msg << " ";
        for(int i = 0; i < 3; i++)
        cout << "f[" << i << "] = "
        << f[i] << endl;
    }
};
class WData1 : public Persistent, public Data {
public:
    WData1(float f0 = 0.0, float f1 = 0.0,
        float f2 = 0.0) : Data(f0, f1, f2),
    Persistent(sizeof(WData1)) {
        cout<<"size of w1 "<<sizeof(WData1)<<endl;
    }
};
class WData2 : public Data, public Persistent {
public:
    WData2(float f0 = 0.0, float f1 = 0.0,
        float f2 = 0.0) : Data(f0, f1, f2),
    Persistent(sizeof(WData2)) {
        cout<<"size of w2 "<<sizeof(WData2)<<endl;
    }
};
int main() {
    {
        ofstream f1("f1.dat"), f2("f2.dat"),f3("f3.dat"), f4("f4.dat");
        WData1 d1(1.1, 2.2, 3.3);
        WData2 d2(4.4, 5.5, 6.6);
        WData1 d3(1.1, 2.2, 3.3);
        WData2 d4(4.4, 5.5, 6.6);
        d1.print("d1 before storage");
        d2.print("d2 before storage");
        d3.print("d3 before storage");
        d4.print("d4 before storage");
        d1.write(f1);
        d2.write(f2);
        d3.write(f3);
        d4.write(f4);
    } // Closes files
    ifstream f1("f1.dat"), f2("f2.dat"),f3("f3.dat"), f4("f4.dat");

    WData1 d1;
    WData2 d2;
    WData1 d3;
    WData2 d4;
    d1.read(f1);
    d2.read(f2);
    d3.read(f3);
    d4.read(f4);
    d1.print("d1 before storage");
    d2.print("d2 before storage");
    d3.print("d3 before storage");
    d4.print("d4 before storage");
} ///:~

它产生意外的输出：类WData1的对象被正确保留，但WData2的对象不是。在试图找到问题的根源和可能的修复时，我发现，问题仅在于读取WData2（它正确存储在文件中）。为了使这段代码按预期工作，我不得不改变继承顺序：

 WData2 : public Data, public Persistent{...

到

 WData2 :  public Persistent, public Data{...

我很好奇为什么继承顺序在这种情况下有所不同。它不应该没有区别吗？

Answer 1

问题在于，在Persistent类中，您使用this指向要read/write的内存的开头。这是一个问题，因为您将此作为继承类使用。因此，除非Persistent不是第一个继承的类，否则this将不会指向基类的开头：

这是Wdata1和Wdata2的内容（忽略了填充和对齐）：

      Wdata1
      +-----------+----------------------+
      | objSize   |  f[0]   f[1]   f[2]  |
      +-----------+----------------------+
      |Persistent |        Data          |
      ^
      |
this (of Persistent)

      |<-   what you read/ write       ->|



      WData2
      +----------------------+-----------+
      |  f[0]   f[1]   f[2]  | objSize   |
      +----------------------+-----------+
      |        Data          | Persistent|
                             ^
                             |
                    this (of Persistent)

                             |<-   what you read/ write       ->|

Answer 2

问题在于Persistent：

中的来电

out.write((char*)this, objSize);
in.read((char*)this, objSize);

此处，this是Persistent*，并且假定它指向完整对象的开头。只有当Persistent是第一个基类时才会这样。

要到处工作，你可以做这个鲜为人知的技巧：

void *that = dynamic_cast<void*>(this);
out.write((char*)that, objSize);
in.read((char*)that, objSize);

dynamic_cast<void*>()保证您将拥有指向派生程度最高的对象的指针。

警告！：唉！除非类型是多态，否则这将无效。并且Persistent技巧不适用于多态类型。所以这个答案实际上是无用的。我没有删除它，因为为什么你不应该这样做可能仍然很有趣。

Answer 3

问题的原因可能是导致WData2构造函数初始化列表中的基类初始化。您需要以继承基类的相同顺序调用基础构造函数。

所以改变

WData2(...) : Data(...), Persistent(...) { ... }

到

WData2(...) : Persistent(...), Data(...) { ... }

更改继承顺序会产生不同的结果

3 个答案: