Ich habe das Beispiel-Demo-Programm mit einemboost :: interprocess Container von Containern Art. Ich verwende die Klasse aber auch gerne als normale Klasse in meinem Prozessspeicher. Kann mir jemand helfen, einen Konstruktor zu schreiben, der keine Argumente benötigt, um die Klasse in meinem aktuellen Prozessspeicher zu initialisieren.

#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <shmfw/serialization/interprocess_vector.hpp>
#include <stdlib.h>     /* srand, rand */
#include <time.h>       /* time */


using namespace boost::interprocess;
//Alias an STL-like allocator of ints that allocates ints from the segment
typedef allocator<int, managed_shared_memory::segment_manager>  ShmemAllocator;

//Alias a vector that uses the previous STL-like allocator
typedef vector<int, ShmemAllocator> MyVector;

typedef allocator<void, managed_shared_memory::segment_manager >                           void_allocator;

class MyStruct {
public:
    MyVector myVector;
    //Since void_allocator is convertible to any other allocator<T>, we can simplify
    //the initialization taking just one allocator for all inner containers.
    MyStruct ( const void_allocator &void_alloc )
        : myVector ( void_alloc )
    {}
    // Thats what I like to have       
    //MyStruct ()
    //    : myVector ( ?? )
    //{}
};

int main () {

    // I would like to have something like that working and also the shm stuff below
    // MyStruct x;


    managed_shared_memory segment;
    //A managed shared memory where we can construct objects
    //associated with a c-string
    try {
         segment =  managed_shared_memory( create_only, "MySharedMemory", 65536 );
    } catch (...){
        segment = managed_shared_memory( open_only, "MySharedMemory" );
    }

    //Initialize the STL-like allocator
    const ShmemAllocator alloc_inst ( segment.get_segment_manager() );

    MyStruct *myStruct_src =  segment.find_or_construct<MyStruct> ( "MyStruct" ) ( alloc_inst );
    srand (time(NULL));
    myStruct_src->myVector.push_back ( rand() );

    MyStruct *myStruct_des =  segment.find_or_construct<MyStruct> ( "MyStruct" ) ( alloc_inst );

    for ( size_t i = 0; i < myStruct_src->myVector.size(); i++ ) {
        std::cout << i << ": " << myStruct_src->myVector[i] << " = " << myStruct_des->myVector[i] << std::endl;
    if(myStruct_src->myVector[i] != myStruct_des->myVector[i]) {
      std::cout << "Something went wrong!" << std::endl;
    }
    }


    //segment.destroy<MyVector> ( "MyVector" );
    return 0;
}