What it the preferred method to write a class to a file?

[Charles D Hixson]

Stewart Gordon wrote:
> Charles D Hixson wrote:
>> I'm thinking that I should build two methods, possibly
>> called write and print where write would export a "binary"
>> version of the class that is not intended to be human
>> readable and print would export something with, e.g.,
>> numbers translated into strings.
>>
>> It appears as if the methods should be instance methods of
>> the class.  It looks as if write should be implemented
>> something like:
>> void write(Stream stream)
>> {  stream.writeExact(&this, this.sizeof);    }
> 
> That won't work at all.  Because classes have reference semantics, all
> it'll do is write out the memory address of the object.
> 
> Even so, the arrangement of members within a class isn't guaranteed:
> 
> http://www.digitalmars.com/d/class.html
> "The D compiler is free to rearrange the order of fields in a class to
> optimally pack them in an implementation-defined manner. Consider the
> fields much like the local variables in a function - the compiler
> assigns some to registers and shuffles others around all to get the
> optimal stack frame layout. This frees the code designer to organize the
> fields in a manner that makes the code more readable rather than being
> forced to organize it according to machine optimization rules. Explicit
> control of field layout is provided by struct/union types, not classes."
> 
> Moreover, every object includes a pointer to the vtable, which will
> screw things up when the program is run again and the data is read back
> in.  Add to that any pointers, dynamic arrays or object references that
> your class may contain....
> 
>> Though probably in this version I'd want to include
>> delimiters, a type id, and a length to facilitate writing
>> the corresponding read routing (which would need to be a
>> class method).
> 
> You need to define a data format that includes all the information that
> is needed in order to reconstruct the object.  Start with a type ID of
> your own devising (if there's any chance that more than one type fits
> the context), and write out each member.  For primitive types, static
> arrays and structs that have no reference-semantics members, this is
> trivial.  For dynamic arrays, write out the length followed by the
> contents.  For object references within the class, follow this principle
> recursively.  Be careful of any potential circularity.
> 
>> It this the best approach?   Also are there any suggestions
>> as to a reasonable way to specify the type id, so that it
>> would be the same from run to run? 
> 
> Only the one you suggest next:
> 
>> Should I keep track of the ids myself (manually)?
> <snip>
> 
> Yes.
> 
> Stewart.
> 
Thanks. (Sigh...I guess this is all tied in with introspection.)