E 'sicuro per serializzare un grezzo boost :: variante?

Question

boost :: variante sostiene che si tratta di un tipo di valore. Questo significa che è sicuro di scrivere semplicemente fuori la rappresentazione cruda di un boost :: variant e ricaricarlo in seguito, fintanto che contiene solo i tipi di POD? Si supponga che sarà ricaricato dal codice compilato dallo stesso compilatore, e la stessa versione di spinta, sulla stessa architettura.

Inoltre, (probabilmente) in modo equivalente, può dare impulso :: variante essere utilizzato in memoria condivisa?

Answer 1

Per quanto riguarda la serializzazione: Dovrebbe funzionare, sì. Ma perché non si utilizza il meccanismo visita di boost::variant di scrivere il tipo effettivo contenuta nella variante?

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;
}

Per quanto riguarda la memoria condivisa: boost::variant non esegue le allocazioni di heap, in modo da poter inserire in memoria condivisa proprio come un int, assumendo una corretta sincronizzazione, ovviamente

.

Inutile dire che, come hai detto, quanto sopra è valida solo se la variante può contenere solo i tipi di POD.

Answer 2

Prova appena compreso boost / serializzazione / variant.hpp; lo fa il lavoro per voi.