Re: writing binary files
On Jan 26, 5:31 pm, =D6=F6 Tiib <oot...@hot.ee> wrote:
On Jan 26, 6:31 pm, aaragon <alejandro.ara...@gmail.com> wrote:
I'm experimenting with binary files, and it seems pretty
straightforward. It seems that I have to use the read and
write member functions, inherited by ostream. However, there
is something I really don't like about using this function
and I want to know if there is a way to avoid it.
Let's say you're writing an double to the binary file, a very simple
example:
int main() {
std::ofstream fout("test.out", std::ofstream::b=
inary);
double test = 10.;
fout.write((char*)&test, sizeof(double));
You can use C++ cast there:
fout.write( reinterpret_cast<char*>(&test),
sizeof(double) );
Which does make it clearer that what he's doing isn't likely to
work.
fout.close();
close() is not needed, ofstream destructor does it.
Not really. He's forgotten an important part: you have to check
the status of the stream after the close.
And return EXIT_ERROR if it's not OK. (The only time counting
on the close in the destructor is acceptable is in case of a
lower level error, when you're going to delete the file and
return an error status anyway.)
}
I hate to see the C cast in the write function. Is there a
way to better write this line? I really want to avoid the C
way of casting.
Bare binary form is probably bad idea to serialize something.
On platform you write the sizes alignments and so on may be
different than on platform you read.
Better write some supporting information too, what it is and
how lot of bytes it contains (it is called TLV
tag-length-value). Use memcpy() to copy all such information
into char vector and then write it to file all at once.
memcpy() takes void* and you must not cast anything into void*
that does not do so silently.
memcpy also just copies the bits of the internal representation,
so it is generally not a good idea either.
--
James Kanze