I am trying to create a C++ map with a vector value inside a boost memory mapped file

I think the problem is that it cannot construct allocators for vectors. You could define an allocator class that has a default ctor which uses mmfile.get_segment_manager() (then you need to set that through some static data). But a quick fix can be, instead of using the [] operator to add new value, use emplace.

auto it = mapptr->emplace("Hello", mmfile.get_segment_manager()).first;
it->second.push_back(17);

Sorry, I haven't tested it.

The issue is that the vector can't be created without an allocator (basicly it needs to know which segment it should allocate within - it could be different from the segment the map is in). One way to get around this is creating a new type that uses mmfile global object in a constructor:

bi::managed_mapped_file mmfile(bi::open_or_create, "map_iv.dat", 10000000);

    int main() {
        typedef bi::allocator<int, bi::managed_mapped_file::segment_manager> int_allocator;
        struct MyVec : public boost::container::vector<int, int_allocator>{
            MyVec() : boost::container::vector<int, int_allocator>{mmfile.get_segment_manager()}{};
        };
        //..
    }

or you could call emplace instead of push_back as shown here.

Besides that, Im guessing it's a mistake to use std::string in mapped_file - just a note though. The following is from a boost example - which has been modified to use the same data structure while also allocating the string in the segment:

#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/allocators/allocator.hpp>
#include <boost/interprocess/containers/map.hpp>
#include <boost/interprocess/containers/vector.hpp>
#include <boost/interprocess/containers/string.hpp>



int main ()
{
    using namespace boost::interprocess;

    //Typedefs of allocators and containers
    typedef managed_shared_memory::segment_manager                       segment_manager_t;
    typedef allocator<void, segment_manager_t>                           void_allocator;
    typedef allocator<int, segment_manager_t>                            int_allocator;
    typedef vector<int, int_allocator>                                   int_vector;
    typedef allocator<char, segment_manager_t>                           char_allocator;
    typedef basic_string<char, std::char_traits<char>, char_allocator>   char_string;


    //Definition of the map holding a string as key and complex_data as mapped type
    typedef std::pair<const char_string, int_vector>                      map_value_type;
    typedef std::pair<char_string, int_vector>                            movable_to_map_value_type;
    typedef allocator<map_value_type, segment_manager_t>                    map_value_type_allocator;
    typedef map< char_string, int_vector, std::less<char_string>, map_value_type_allocator> complex_map_type;

   shared_memory_object::remove("MySharedMemory");
   remove_shared_memory_on_destroy remove_on_destroy("MySharedMemory");
   {
      //Create shared memory
      managed_shared_memory segment(create_only,"MySharedMemory", 65536);

      //An allocator convertible to any allocator<T, segment_manager_t> type
      void_allocator alloc_inst (segment.get_segment_manager());

      //Construct the shared memory map and fill it
      complex_map_type *mymap = segment.construct<complex_map_type>
         //(object name), (first ctor parameter, second ctor parameter)
            ("MyMap")(std::less<char_string>(), alloc_inst);

      for(int i = 0; i < 100; ++i){
         //Both key(string) and value(complex_data) need an allocator in their constructors
         char_string  key_object(alloc_inst);
         int_vector mapped_object(alloc_inst);
         mapped_object.push_back(i);
         map_value_type value(key_object, mapped_object);
         //Modify values and insert them in the map
         mymap->insert(value);
      }
   }
   return 0;
}

Try it yourself