Как boost :: serialization можно использовать с std :: shared_ptr из C ++ 11?

Question

Я знаю, что есть Модуль повышения для сериализации из boost::shared_ptr, но я не могу найти ничего для std::shared_ptr.

Кроме того, я не знаю, как это легко реализовать.Боюсь, что следующий код

namespace boost{namespace serialization{
template<class Archive, class T>
inline void serialize(Archive & ar, std::shared_ptr<T> &t, const unsigned int version)
{
  if(Archive::is_loading::value) {T*r;ar>>r;t=r;}
  else {ar<<t.get();}
}
}}//namespaces

не работает.Действительно, если к какому-либо объекту обращались несколько раз, он будет загружен при первом запуске ar>>r, и после этого будет скопирован только указатель.Однако мы создадим несколько shared_ptr объектов, указывающих на него, и, следовательно, уничтожим его более одного раза.

Есть какие-нибудь идеи по этому поводу?

Некоторые технические подробности о системе, которую я использую:

• ОС: Ubuntu 11.10 (x64)
• Компилятор: g ++ (Ubuntu / Linaro 4.6.1-9ubuntu3) 4.6.1
• буст версия: 1.46.1 (устанавливается с sudo apt-get install libboost-dev)

Answer 1

Эй, ребята, я наконец-то нашел решение о том, как сериализовать std :: shared_ptr, используя сериализацию boost.Все, что вам нужно, это следующий фрагмент кода (пояснение приведено ниже):

#include <boost/serialization/split_free.hpp>
#include <boost/unordered_map.hpp>

//---/ Wrapper for std::shared_ptr<> /------------------------------------------

namespace boost { namespace serialization {

template<class Archive, class Type>
void save(Archive & archive, const std::shared_ptr<Type> & value, const unsigned int /*version*/)
{
    Type *data = value.get();
    archive << data;
}

template<class Archive, class Type>
void load(Archive & archive, std::shared_ptr<Type> & value, const unsigned int /*version*/)
{
    Type *data;
    archive >> data;

    typedef std::weak_ptr<Type> WeakPtr;
    static boost::unordered_map<void*, WeakPtr> hash;

    if (hash[data].expired())
    {
         value = std::shared_ptr<Type>(data);
         hash[data] = value;
    }
    else value = hash[data].lock();
}

template<class Archive, class Type>
inline void serialize(Archive & archive, std::shared_ptr<Type> & value, const unsigned int version)
{
    split_free(archive, value, version);
}

}}

Этот код просто сериализует объект, управляемый std :: shared_ptr, в функции save ().Если несколько экземпляров std :: shared_ptr указывают на один и тот же объект, сериализация прироста будет автоматически сохранять его только один раз.Волшебство происходит в load (), где boost сериализации возвращает необработанный указатель на объект (данные).Этот необработанный указатель ищется в хеш-коде, который содержит weak_ptr для каждого необработанного указателя.В случае истечения срока действия strong_ptr в хэше мы можем безопасно создать новый экземпляр shared_ptr, позволить ему управлять необработанным указателем и сохранить в хеше weak_ptr.В случае, если не используется срок действия weak_ptr, мы просто блокируем его, чтобы вернуть shared_ptr.Таким образом, счетчик ссылок будет правильным.

Answer 2

Начиная с Boost 1.56, библиотека сериализации имеет встроенную поддержку для std :: shared_ptr. Вам не нужно реализовывать свои собственные вспомогательные функции сериализации, если вы можете использовать более новую версию библиотеки.

Answer 3

Сериализация обеспечивается бустом, а не стандартной библиотекой, и хотя shared_ptr включен в стандарт, он является частью TR1 (технический отчет 1).

TR1 на данный момент не имеет сериализации. Поэтому я бы порекомендовал вам использовать общий указатель boost.

Answer 4

Последние версии Boost Serialization включают поддержку всех стандартных интеллектуальных указателей библиотек.

Answer 5

Вы не сказали, что означает "не работает"; это не компилируется? Это не загружает / хранит значение правильно? Это не .. что?

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

Во-первых, вы не сделали правильный указатель в процедуре загрузки. Давайте разберемся с этим:

inline void serialize(Archive & ar, std::shared_ptr<T> &t, const unsigned int version) {
    if (1) { //unimportant
        T* r;
        ar >> r;
        t = r;
    }
}

Когда вы создаете объект из std :: shared_ptr, вы создаете экземпляр шаблона класса, чтобы обеспечить возможность указателя (как вы знаете). Если вы сделали с int, он будет работать как указатель int. Однако простая передача типа как T НЕ означает, что созданный указатель этого типа будет автоматически использовать этот шаблон; действительно, вы создаете пустой указатель с помощью T * r. Это также может быть int * r. Вы тогда не можете инициализировать это с новым; г может указывать куда угодно. Если он был правильно инициализирован с новым, вы МОЖЕТЕ получить правильный подсчет ссылок для создания / удаления этого объекта; это одна из областей, где std :: shared_ptr не кажется мне стоящим. Я думаю, что назначение с пустым указателем считается второй ссылкой, а не первой, но я могу ошибаться? Во всяком случае, это не проблема. Вы, вероятно, портите кучу; компилятор должен выдавать предупреждение об использовании неинициализированного указателя, это удивительно, что это не так. Надеюсь, у вас не отключены предупреждения.

Если я правильно помню, эту декларацию r необходимо заменить на:

std::shared_ptr<T> r = new std::shared_ptr<T>;

Хотя это может быть

std::shared_ptr<T> r = new std::shared_ptr<T>(r());

Я некоторое время не использовал shared_ptr.

TR1, между прочим, отсутствовал как минимум 2 года. Это основано на Boost's shared_ptr. Я не знаю, почему вы используете Boost 1.46, но я думаю, что он вышел к тому времени, когда shared_ptr стал частью стандарта? Так должно быть совместимо ...?

Так или иначе, вторая потенциальная ошибка приходит с

t = r;

Я предполагаю - неправильно? - что вы хотите уменьшить счетчик ссылок на t, переназначив его (и, возможно, уничтожив объект, на который указывает t). Если вы хотите скопировать его, вы, конечно, будете использовать:

*t = *r;

и убедитесь, что ваш конструктор копирования работает правильно.

Answer 6

Это результат скручивания вашего собственного на основе общего заголовка общего указателя, например, на основе <boost/serialization/shared_ptr.hpp>.

Просто скопируйте и вставьте ниже в файл заголовка и включите его:

#ifndef BOOST_SERIALIZATION_STD_SHARED_PTR_HPP
#define BOOST_SERIALIZATION_STD_SHARED_PTR_HPP

// MS compatible compilers support #pragma once
#if defined(_MSC_VER) && (_MSC_VER >= 1020)
# pragma once
#endif

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// shared_ptr.hpp: serialization for boost shared pointer

// (C) Copyright 2004 Robert Ramey and Martin Ecker
// Use, modification and distribution is subject to the Boost Software
// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

//  See http://www.boost.org for updates, documentation, and revision history.

#include <cstddef> // NULL

#include <boost/config.hpp>
#include <boost/mpl/integral_c.hpp>
#include <boost/mpl/integral_c_tag.hpp>

#include <boost/detail/workaround.hpp>
#include <memory>

#include <boost/serialization/split_free.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/version.hpp>
#include <boost/serialization/tracking.hpp>

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// shared_ptr serialization traits
// version 1 to distinguish from boost 1.32 version. Note: we can only do this
// for a template when the compiler supports partial template specialization

#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
    namespace boost {
    namespace serialization{
        template<class T>
        struct version< ::std::shared_ptr< T > > {
            typedef mpl::integral_c_tag tag;
            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
            typedef BOOST_DEDUCED_TYPENAME mpl::int_<1> type;
            #else
            typedef mpl::int_<1> type;
            #endif
            #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570))
            BOOST_STATIC_CONSTANT(int, value = 1);
            #else
            BOOST_STATIC_CONSTANT(int, value = type::value);
            #endif
        };
        // don't track shared pointers
        template<class T>
        struct tracking_level< ::std::shared_ptr< T > > {
            typedef mpl::integral_c_tag tag;
            #if BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3206))
            typedef BOOST_DEDUCED_TYPENAME mpl::int_< ::boost::serialization::track_never> type;
            #else
            typedef mpl::int_< ::boost::serialization::track_never> type;
            #endif
            #if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x570))
            BOOST_STATIC_CONSTANT(int, value = ::boost::serialization::track_never);
            #else
            BOOST_STATIC_CONSTANT(int, value = type::value);
            #endif
        };
    }}
    #define BOOST_SERIALIZATION_SHARED_PTR(T)
#else
    // define macro to let users of these compilers do this
    #define BOOST_SERIALIZATION_SHARED_PTR(T)                         \
    BOOST_CLASS_VERSION(                                              \
        ::std::shared_ptr< T >,                                     \
        1                                                             \
    )                                                                 \
    BOOST_CLASS_TRACKING(                                             \
        ::std::shared_ptr< T >,                                     \
        ::boost::serialization::track_never                           \
    )                                                                 \
    /**/
#endif

namespace boost {
namespace serialization{

#ifndef BOOST_SERIALIZATION_SHARED_PTR_HPP
struct null_deleter {
    void operator()(void const *) const {}
};
#endif

/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8
// serialization for shared_ptr

template<class Archive, class T>
inline void save(
    Archive & ar,
    const std::shared_ptr< T > &t,
    const unsigned int /* file_version */
){
    // The most common cause of trapping here would be serializing
    // something like shared_ptr<int>.  This occurs because int
    // is never tracked by default.  Wrap int in a trackable type
    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
    const T * t_ptr = t.get();
    ar << boost::serialization::make_nvp("px", t_ptr);
}

template<class Archive, class T>
inline void load(
    Archive & ar,
    std::shared_ptr< T > &t,
    const unsigned int /*file_version*/
){
    // The most common cause of trapping here would be serializing
    // something like shared_ptr<int>.  This occurs because int
    // is never tracked by default.  Wrap int in a trackable type
    BOOST_STATIC_ASSERT((tracking_level< T >::value != track_never));
    T* r;
    ar >> boost::serialization::make_nvp("px", r);
    ar.reset(t,r);
}

template<class Archive, class T>
inline void serialize(
    Archive & ar,
    std::shared_ptr< T > &t,
    const unsigned int file_version
){
    // correct shared_ptr serialization depends upon object tracking
    // being used.
    BOOST_STATIC_ASSERT(
        boost::serialization::tracking_level< T >::value
        != boost::serialization::track_never
    );
    boost::serialization::split_free(ar, t, file_version);
}

} // namespace serialization
} // namespace boost

#endif // BOOST_SERIALIZATION_STD_SHARED_PTR_HPP

Здесь вы можете просмотреть различия <boost/serialization/shared_ptr.hpp>

В основном

• переименован, включая охранник
• изменен boost::shared_ptr наstd::shared_ptr
• включено <memory> вместо <boost/shared_ptr.hpp>
• защищено null_deleter от переопределения в случае, если вы также используете boost::shared_ptr
• удалено BOOST_SERIALIZATION_SHARED_PTR_132_HPP - что угодноэто примерно?

Пока, похоже, все работает нормально.

Answer 7

Это улучшение решения denim , которое поддерживает загрузку shared_ptr, который указывает на одну и ту же память, но с разными типами. Эта проблема может возникнуть, если архив содержит одновременно shared_ptr и shared_ptr, которые указывают на один и тот же объект, где A наследуется от B.

namespace boost {
namespace serialization {

    template<class Archive, class Type>
    void save(Archive & archive, const std::shared_ptr<Type> & value, const unsigned int /*version*/)
    {
        Type *data = value.get();
        archive << data;
    }

    static std::map<void*, std::weak_ptr<void>> hash;

    template<class Archive, class Type>
    void load(Archive & archive, std::shared_ptr<Type> & value, const unsigned int /*version*/)
    {
        Type *data;
        archive >> data;

        if (hash[data].expired())
        {
            std::shared_ptr<void> ptr(data);
            value = static_pointer_cast<Type>(ptr);
            hash[data] = ptr;
        }
        else value = static_pointer_cast<Type>(hash[data].lock());
    }

    template<class Archive, class Type>
    inline void serialize(Archive & archive, std::shared_ptr<Type> & value, const unsigned int version)
    {
        split_free(archive, value, version);
    }

}}

Как слабость этой реализации - одна массивная карта.