Writing contents of an std::vector to a binary file! ;o)

[shrink_tubing]

Hi,

I have already written the contents of a regular good old array to a bin file many times. The program I've made needs some resizing to take place in it though - std::vector needed. But I want to write the contents of that std::vector out to a binary file. Up to now it's used this command for a regular array:

std::ofstream writeFile;
writeFile.open("Mesh.bin", std::ios::out | std::ios::binary);
writeFile.write((char*)newVertexArray, VERTEXARRAYSIZE * sizeof(float));

But I know that happy simplicity will abruptly end when trying to do it with an std::vector. I haven't a clue how to do this. Has *anyone* got any ideas.

Thanks!

[ctrl_freak]

Vectors aren't contiguous blocks of memory, so you can't simply write the block of memory to a file. Instead, you'll have to manually write each element (assuming each element is itself a contiguous block of memory, i.e. no pointers). You should be able to do something clever with std::copy and an OutputIterator, if that's closer to what you were looking for.

[whiteflags]

Perhaps this is a defect in the C++ standard, as std::string has the same problem, but the intent is that vector is contiguous. If your implementation does not store a vector in contiguous memory, it should not be considered as conforming to the Standard.

As the fix to store std::strings in contiguous memory is vector<char>, it had better be guaranteed to be contiguous.

As it happens, no implementation I know of fails in this regard.

[iMalc]

Vectors aren't contiguous blocks of memory, so you can't simply write the block of memory to a file.

Vectors contents are meant to be guaranteed by the standard to be contiguous in memory. The problem here is that you cant cast the vector itself that way. You instead need to get the address of the first item.

The following is a legitimate way of doing it. Also note the other changes I made:

std::ofstream writeFile;
writeFile.open("Mesh.bin", std::ios::out | std::ios::binary);
if (!newVertexArray.empty())
    writeFile.write(&newVertexArray[0], newVertexArray.size() * sizeof(float));

[shrink_tubing]

Well I think these replies are great! Somone else taking so much time to help with no monetary reward. Thank you so much this is enough information for me to go forward from here (I hope!)

[shrink_tubing]

Excellent stuff this worked:

std::ofstream writeFile;
writeFile.open("Mesh.bin", std::ios::out | std::ios::binary);
if (!newVertexArray.empty())
    writeFile.write((char*)&newVertexArray[0], newVertexArray.size() * sizeof(float));

It still demanded the first address be cast to a char*. Thanks alot this will really help me write better code.

[laserlight]

It still demanded the first address be cast to a char*.

Yes, though you might want to use a C++-style cast to make the cast more explicit:

std::ofstream writeFile;
writeFile.open("Mesh.bin", std::ios::out | std::ios::binary);
if (!newVertexArray.empty())
    writeFile.write(reinterpret_cast<char*>(&newVertexArray[0]),
        newVertexArray.size() * sizeof(newVertexArray[0]));

I have also chosen to change the sizeof expression to one that does not need to be changed should the value type of newVertexArray change.

[shrink_tubing]

Thank you so much madam that's great