CODEWITHSUNDEEP
c++serializationboostshared-memoryboost-variant
bdonlan
bdonlan

Reputation: 231253

Is it safe to serialize a raw boost::variant?

boost::variant claims that it is a value type. Does this mean that it's safe to simply write out the raw representation of a boost::variant and load it back later, as long as it only contains POD types? Assume that it will be reloaded by code compiled by the same compiler, and same version of boost, on the same architecture.

Also, (probably) equivalently, can boost::variant be used in shared memory?

Upvotes: 6

Views: 4559

Answers (3)

sanjivgupta
sanjivgupta

Reputation: 456

The memory layout of boost::variant is as: { int which; storage_t storage;}. The storage_t is determined by the implementation to be the max size required by your usage. so if your storage_t turns out to be 8-byte or more (OR requiring an 8-byte alignment), there might be a 4-byte padding involved between 'which' and 'storage', depending upon the compiler or compiler options. So as the accepted answer says, it is safer to serialize using visitation.

Upvotes: 0

spiderlama
spiderlama

Reputation: 1683

Try just including boost/serialization/variant.hpp; it does the work for you.

Upvotes: 15

Marc Mutz - mmutz
Marc Mutz - mmutz

Reputation: 25303

Regarding serialisation: It should work, yes. But why don't you use boost::variant's visitation mechanism to write out the actual type contained in the variant?

struct variant_serializer : boost::static_visitor<void> {
    template <typename T>
    typename boost::enable_if< boost::is_pod<T>, void>::type
    operator()( const T & t ) const {
        // ... serialize here, e.g.
        std::cout << t;
    }
};

int main() {

    const boost::variant<int,char,float,double> v( '1' );

    variant_serializer s;
    boost::apply_visitor( s, v );

    return 0;
}

Regarding shared memory: boost::variant does not perform heap allocations, so you can place it into shared memory just like an int, assuming proper synchronisation, of course.

Needless to say, as you said, the above is only valid if the variant can only contain POD types.

Upvotes: 7

Related Questions