How to reduce the size of a fstream file in C++

Question

What is the best way to cut the end off of a fstream file in C++ 11

I am writing a data persistence class to store audio for my audio editor. I have chosen to use fstream (possibly a bad idea) to create a random access binary read write file.

Each time I record a little sound into my file I simply tack it onto the end of this file. Another internal data structure / file, contains pointers into the audio file and keeps track of edits.
When I undo a recording action and then do something else the last bit of the audio file becomes irrelevant. It is not referenced in the current state of the document and you cannot redo yourself back to a state where you can ever see it again. So I want to chop this part of the file off and start recording at the new end. I don't need to cut out bitts in the middle, just off the end.

When the user quits this file will remain and be reloaded when they open the project up again.

In my application I expect the user to do this all the time and being able to do this might save me as much as 30% of the file size. This file will be long, potentially very, very long, so rewriting it to another file every time this happens is not a viable option.

Rewriting it when the user saves could be an option but it is still not that attractive.

I could stick a value at the start that says how long the file is supposed to be and then overwrite the end to recycle the space but in the mean time. If I wanted to continually update the data store file in case of crash this would mean I would be rewriting the start over and over again. I worry that this might be bad for flash drives. I could also recomputed the end of the useful part of the file on load, by analyzing the pointer file but in the mean time I would be wasting all that space potentially, and that is complicated.

Is there a simple call for this in the fstream API?

Am I using the wrong library? Note I want to stick to something generic STL I preferred, so I can keep the code as cross platform as possible.

I can't seem to find it in the documentation and have looked for many hours. It is not the end of the earth but would make this a little simpler and potentially more efficient. Maybe I am just missing it somehow.

Thanks for your help Andre'

Answer 1

Is there a simple call for this in the fstream API?

If you have C++17 compiler then use std::filesystem::resize_file . In previous standards there was no such thing in standard library.

With older compilers ... on Windows you can use SetFilePointer or SetFilePointerEx to set the current position to the size you want, then call SetEndOfFile . On Unixes you can use truncate or ftruncate . If you want portable code then you can use Boost.Filesystem . From it is simplest to migrate to std::filesystem in the future because the std::filesystem was mostly specified based on it.

Answer 2

If you have variable, that contains your current position in the file, you could seek back for the length of your "unnedeed chunk", and just continue to write from there.

// Somewhere in the begining of your code:
std::ofstream *file = new std::ofstream();
file->open("/home/user/my-audio/my-file.dat");
// ...... long story of writing data .......

// Lets say, we are on a one millin byte now (in the file)
int current_file_pos = 1000000;
// Your last chunk size:
int last_chunk_size = 12345;
// Your chunk, that you are saving
char *last_chunk = get_audio_chunk_to_save();
// Writing chunk
file->write(last_chunk, last_chunk_size);
// Moving pointer:
current_file_pos += last_chunk_size;
// Lets undo it now!
current_file_pos -= last_chunk_size;
file->seekp(current_file_pos);
// Now you can write new chunks from the place, where you were before writing and unding the last one!
// .....
// When you want to finally write file to disk, you just close it
file->close();
// And when, truncate it to the size of current_file_pos
truncate("/home/user/my-audio/my-file.dat", current_file_pos);

Unfortunatelly, you'll have to write a crossplatform function truncate , that would call SetEndOfFile in windows, and truncate in linux. It's easy enough with using preprocessor macros.