Как обновить элемент структуры в двоичных файлах

Я оценил следующие решения:

1. обновить в новом файле, переименовать его в старую в конце
2. обновление в том же файле с потоком с двумя файловыми позициями, чтение и запись, но я не быстро нашел поддержку для такой вещи
3. обновление в том же файле двумя потоками, чтение и запись, но риск переопределения слишком большой для меня (даже если он защищен от перекрытий)

Поэтому я выбираю первый, самый простой в любом случае.

#include <string>
#include <vector>
#include <fstream>
#include <cstdio>
#include <assert.h>

Я добавил следующую структуру в вашу структуру:

size_t SizeWrittenToFile() const 
{
  return 2*sizeof(size_t)+term.length()+pl.size()*sizeof(int);
}

Функции чтения и записи в основном такие же, как и у вас, кроме того, что я не хочу писать в string:c_str() указатель (хотя это уродливое решение должно работать на всех известных компиляторах).

bool ReadNext(std::istream& in, mapItem& item)
{
size_t size;
in.read(reinterpret_cast<char*>(&size), sizeof(size_t));
if (!in)
    return false;

std::istreambuf_iterator<char> itIn(in); 
std::string& out = item.term;
out.reserve(size);
out.clear();    //  this is necessary if the string is not empty
for (std::insert_iterator<std::string> itOut(out, out.begin()); 
     in && (out.length() < size); itIn++, itOut++)
    *itOut = *itIn;

assert(in);
if (!in)
    return false;

in.read(reinterpret_cast<char*>(&size), sizeof(size_t));
if (!in)
    return false;

std::vector<int>& out2 = item.pl;
out2.resize(size);  //  unfortunately reserve doesn't work here
in.read(reinterpret_cast<char*>(&out2[0]), size * sizeof(int));
assert(in);

return true;
}

//добавлен "заголовок" для отметки полных данных (для записи "атомарно")

bool WriteNext(std::ostream& out, const mapItem& item)
{
size_t size = item.term.length();
out.write(reinterpret_cast<const char*>(&size), sizeof(size_t));
if (!out)
    return false;
out.write(item.term.c_str(), size);
if (!out)
    return false;

size = item.pl.size();
out.write(reinterpret_cast<const char*>(&size), sizeof(size_t));
if (!out)
    return false;
out.write(reinterpret_cast<const char*>(&item.pl[0]), size * sizeof(int));
if (!out)
    return false;

return true;
}

Функции обновления выглядят следующим образом:

bool UpdateItem(std::ifstream& in, std::ofstream& out, const mapItem& item)
{
mapItem it;
bool result;
for (result = ReadNext(in, it); result && (it.term != item.term); 
     result = ReadNext(in, it))
    if (!WriteNext(out, it))
        return false;
if (!result)
    return false;

//  write the new item content
assert(it.term == item.term);
if (!WriteNext(out, item))
    return false;

for (result = ReadNext(in, it); result; result = ReadNext(in, it))
    if (!WriteNext(out, it))
        return false;

//  failure or just the end of the file?
return in.eof();
}

bool UpdateItem(const char* filename, const mapItem& item)
{
std::ifstream in(filename);
assert(in);

std::string filename2(filename);
filename2 += ".tmp";
std::ofstream out(filename2.c_str());
assert(out);

bool result = UpdateItem(in, out, item);
//  close them before delete
in.close();
out.close();

int err = 0;

if (result)
{
    err = remove(filename);
    assert(!err && "remov_140");
    result = !err;
}
if (!result)
{
    err = remove(filename2.c_str());
    assert(!err && "remov_147");
}
else
{
    err = rename(filename2.c_str(), filename);
    assert(!err && "renam_151");
    result = !err;
}

return result;
}

Вопросов?