跨编译器读写原始对象到磁盘（istream）

Question

I've been porting over some old legacy code. It is 15 years old and used to compile with some old Borland compiler. We are not able to compile the old code due to missing dependencies/compiler.

We have something like this:

class SegmentParameterDataRecord
{
private:
  int32_t parameterId;
  double value;

public:
  SegmentParameterDataRecord() : parameterId(0), value(0.0) {}
  int32_t & getParameterId() { return parameterId; }
  double & getValue() { return value; }

  void read(std::istream & in);
  void write(std::ostream & out);
};

Note the read and write methods. Here they are:

void SegmentParameterDataRecord::read(std::istream & in)
{
  in.read((char *) this, sizeof(*this));
}

void SegmentParameterDataRecord::write(std::ostream & out)
{
  out.write((char *) this, sizeof(*this));
}

This brought up some concerns to me. Note that the old code casts to a char * and processes the data as raw bytes of memory. I believe I am running into problems when I ported this code over to the latest MinGW.

1) Is it possible that the internal memory representation of SegmentParameterDataRecord is different across compilers, and thus it would be problematic to write the SegmentParameterDataRecord on one compiler (15-year old Borland) and then read it on another compiler (recent MinGW)?

2) Is it possible that sizeof(SegmentParameterDataRecord) could be different from a 15-year old Borland compiler to today's MinGW?

3) How likely is this possibility?

Answer 1

Is it possible that sizeof(SegmentParameterDataRecord) could be different from a 15-year old Borland compiler to today's MinGW?

This is definitely possible. In fact, sizeof(int) can be different across compilers and across machines. For example, on a 32-bit machine, sizeof(int) is often 4 bytes, but on a 64-bit machine, sizeof(int) can be 8 bytes.