Binary file write problem in C++

This is my function which creates a binary file

void writefile()
{
    ofstream myfile ("data.abc", ios::out | ios::binary);
    streamoff offset = 1;
    if(myfile.is_open())
    {
        char c='A';
        myfile.write(&c, offset );
        c='B';
        myfile.write(&c, offset );
        c='C';
        myfile.write(&c,offset);
        myfile.write(StartAddr,streamoff (16) );
        myfile.close();
    }
     else
         cout <<开发者_如何学运维 "Some error" << endl ;
}

The value of StartAddr is 1000, hence the expected output file is: A B C 1000 NUL NUL NUL

However, strangely my output file appends this: data.abc

So the final outcome is: A B C 1000 NUL NUL NUL data.abc

Please help me out with this. How to deal with this? Why is this strange behavior?

I recommend you quit with binary writing and work on writing the data in a textual format. You've already encountered some of the problems with writing data. There are still issues for you to come across about reading the data and portability. Expect more pain if you continue this route.

Use textual representations. For simplicity you can put one field per line and use std::getline to read it in. The textual representation allows you to view the data in any text editor, easily. Try using Notepad to view a binary file!

Oh, but binary data is soo much faster and takes up less space in the file. You've already wasted enough time and money than you would gain by using binary data. The speed of computers and huge memory capacities (disk and RAM) make binary representations a thing of the past (except in extreme cases).

As a learning tool, go ahead and use binary. For ease of development and quick schedules (IOW, finishing early), use textual representations.

Search Stack Overflow for "C++ micro optimization" for the justifications.

There are several issues with this code.

For starters, if you want to write individual characters t a stream, you don't need to use ostream::write. Instead, just use ostream::put, as shown here:

myfile.put('A');

Second, if you want to write out a string into a file stream, just use the stream insertion operator:

myfile << StartAddr;

This is perfectly safe, even in binary mode.

As for the particular problem you're reporting, I think that the issue is that you're trying to write out a string of length four (StartAddr), but you've told the stream to write out sixteen bytes. This means that you're writing out the four bytes for the string contents, then the null terminator, and then nine bytes of whatever happens to be in memory after the buffer. In your case, this is two more null bytes, then the meaningless text that you saw after that. To fix this, either change your code to write fewer bytes or, if StartAddr is a string, then just write it using <<.

With the line myfile.write(StartAddr,streamoff (16) ); you are instructing the myfile object to write 16 bytes to the stream starting at the address StartAddr. Imagine that StartAddr is an array of 16 bytes:

char StartAddr[16] = "1000\0\0\0data.b32\0";
myfile.write(StartAddr, sizeof(StartAddr));

Would generate the output that you see. Without seeing the declaration / definition of StartAddr I cannot say for certain, but it appears you are writing out a five byte nul terminated string "1000" followed by whatever happens to reside in the next 11 bytes after StartAddr. In this case, it appears a couple of nul bytes followed by the constant nul terminated string "data.b32" (which the compiler must put somewhere in memory) are what follow StartAddr.

Regardless, it is clear that you overread a buffer.

If you are trying to write a 16 bit integer type to a stream you have a couple of options, both based on the fact that there are typically 8 bits in a byte. The 'cleanest' one would be something like:

char x = (StartAddr & 0xFF);
myfile.write(x);
x = (StartAddr >> 8);
myfile.write(x);

This assumes StartAddr is a 16 bit integer type and does not take into account any translation that might occur (such as potential conversion of a value of 10 [a linefeed] into a carriage return / linefeed sequence).

Alternatively, you could write something like:

myfile.write(reinterpret_cast<char*>(&StartAddr), sizeof(StartAddr));