повысить сериализацию динамических массивов

Question

повысить сериализацию динамических массивов

0

У меня код выглядит примерно так:

struct DataStruct
{
//  some fields here
};

class C1
{
public:
    C1(size_t n)
    {
        ptrData = new DataStruct[n];
        ptrPtrs = new DataStruct*[n];
        for(size_t i=0;i<n;i++)
            ptrPtrs[i] = &ptrData[i];
    }

    virtual ~C1() 
    {
        delete[] ptrData;
        delete[] ptrPtrs;
    }

    DataStruct* ptrData;
    DataStruct** ptrPtrs;
};

и нужно, чтобы он был сериализован, предпочтительно, с помощью boost :: serialization. Я не нашел способов сохранения динамически распределенных массивов, кроме сохранения его элемента по элементу в цикле. Но не уверен, как сохранить второй массив - массив указателей. Можно ли сделать это более или менее удобным способом в boost?

ilya 28 янв. 2014, в 16:12

Источник

Теги:

c++

arrays

serialization

boost

dynamic-arrays

1 ответ

Ещё вопросы

CashCow · Accepted Answer · 2014-01-28T13-12-00.000Z

Невозможно увеличить количество элементов, поскольку все, что у вас есть, - это указатель. Менеджер кучи знает, сколько элементов нужно удалить, когда вы вызываете delete [], но он не доступен для кода, например boost::serialize

Конечно, лучше всего использовать std::vector в первую очередь, но в противном случае создайте класс "обертка", который может использоваться для сериализации, как входящих, так и исходящих.

Если мы будем называть это ArrayWrapper и шаблоном,

template< typename T >
struct ArrayWrapper
{
   T* data = nullptr;
   size_t size = 0;
   ArrayWrapper() = default;
   ArrayWrapper( T* data_, size_t size_ ) : data( data_ ), size( size_ ) {}
};

Теперь вы можете сериализовать один из указателя и известного размера, сначала записав размер, затем каждый элемент.

При сериализации назад вы сначала читаете размер, затем выделяете количество объектов, а затем читаете их.

Конечно, вам нужно управлять своей памятью, а использование std::vector - гораздо лучший вариант.

В общем, вы не храните "указатели", в которых хранятся данные, на которые они указывают. при чтении обратно из архива вы не будете получать те же указатели, которые вошли, вы получите те же данные обратно.

Для этого вы фактически просто архивируете внешний (массив указателей) и получаете его для вызова ArrayWrapper на внутреннем.

ну, я надеялся, что у сериализации есть какой-то адаптер, позволяющий указать длину массива, как в моем ответе выше. вектор здесь не вариант, поскольку, насколько я помню, он не гарантирует, какие элементы не будут перемещаться внутри, поэтому невозможно хранить указатели на элементы вектора.
Ваши векторные элементы не будут перемещены, если вы не измените размер вашего вектора каким-либо образом, и если вы зарезервируете заранее, он никогда не будет перемещать их.
Вы также можете хранить векторы смарт-указателей. Даже если элементы в векторе перемещаются, элементы, на которые они указывают, не будут действовать, и ваши умные указатели останутся действительными. Вы можете использовать shared_ptr для этого и, если вы осторожны, unique_ptr, но не auto_ptr.
Интеллектуальные указатели тоже не подходят, так как это могут быть огромные массивы (длиной в десятки гигабайт) с очень частым доступом, некоторые из которых превышают использование памяти, уменьшают полезный коэффициент использования памяти, а обертки сильно замедляют работу. буду думать о векторах снова, спасибо.
Если их не нужно хранить в непрерывной памяти, вы можете обнаружить, что deque предлагает лучшее решение для вектора. Все еще произвольный доступ, но вы можете обнаружить, что можете использовать более высокую емкость, прежде чем закончится память. Сверхнормативный багаж, который вы получаете, используя вектор, а не массивы, является постоянным (то есть он не увеличивается с количеством предметов, которые есть у вашего вектора). Если это вектор векторов, вы можете упаковать свои внутренние.