Placement New on already existing object in SharedMemory

Question

I have two programs. The first allocates a Shared-Memory file and the second reads from it.. I am using placement-new to place objects into this memory guaranteeing that the objects do NOT use new or allocate any memory outside of the Shared-Memory file.

My Array structure:

template<typename T, size_t Size>
struct SHMArray {
    SHMArray() : ptr(elements) {}
    SHMArray(const SHMArray& other) { std::copy(other.begin(), other.end(), begin()); }

    SHMArray(SHMArray&& other)
    {
        std::swap(other.ptr, ptr);
        std::fill_n(ptr.get(), Size, T());
    }

    ~SHMArray()
    {
        std::fill_n(ptr.get(), Size, T());
    }

    constexpr bool empty() const noexcept
    {
        return Size == 0;
    }

    constexpr size_type size() const noexcept
    {
        return Size;
    }

    T& operator[](std::size_t pos)
    {
        return *(ptr.get() + pos);
    }

    constexpr const T& operator[](std::size_t pos) const
    {
        return *(ptr.get() + pos);
    }

    T* data() noexcept
    {
        return ptr.get();
    }

    constexpr const T* data() const noexcept
    {
        return ptr.get();
    }

private:
    offset_ptr<T> ptr;
    T elements[];
};

Program 1:

int main()
{
    //Allocate a shared memory file of 1mb..
    auto memory_map = SharedMemoryFile("./memory.map", 1024 * 1024, std::ios::in | std::ios::out);

   memory_map.lock();

   //Pointer to the shared memory.
   void* data = memory_map.data();

   //Place the object in the memory..
   SHMArray<int, 3>* array = ::new(data) SHMArray<int, 3>();
   (*array)[0] = 500;
   (*array)[1] = 300;
   (*array)[2] = 200;

   memory_map.unlock(); //signals other program it's okay to read..
}

Program 2:

int main()
{
    //Open the file..
    auto memory_map = SharedMemoryFile("./memory.map", 1024 * 1024, std::ios::in | std::ios::out);

   memory_map.lock();

   //Pointer to the shared memory.
   void* data = memory_map.data();

   //Place the object in the memory..
   //I already understand that I could just cast the `data` to an SHMArray..
   SHMArray<int, 3>* array = ::new(data) SHMArray<int, 3>();
   for (int i = 0; i < array.size(); ++i)
   {
       std::cout<<(*array)[i]<<"\n";
   }

   memory_map.unlock(); //signals other program it's okay to read..
}

1. Program One placed the SHMArray in memory with placement new. Program Two does the same thing on top of program one's already placed object (overwriting it). Is this undefined behaviour? I don't think it is but I want to confirm.

2. Neither program calls the destructor array->~SHMVEC(); I also don't think this leaks as long as I close the MemoryMapped file then it should all be fine.. but I want to make sure this is fine. If I ran the programs again on the same file, it shouldn't be a problem.

I am essentially making the assumption that placement new is working as if I placed a C struct in memory in this particular scenario via: struct SHMArray* array = (struct SHMArray*)data;.. Is this correct?

Answer 1

I am essentially making the assumption that placement new is working as if I placed a C struct in memory in this particular scenario via: struct SHMArray* array = (struct SHMArray*)data;.. Is this correct?

No, this is not correct. Placement new also invokes the object's appropriate constructor. "struct SHMArray* array = (struct SHMArray*)data;" does not invoke any object's constructor. It's just a pointer conversion cast. Which does not invoke anyone's constructor. Key difference.

In your sample code, you do actually want to invoke the templated object's constructor. Although the shown example has other issues, as already mentioned in the comments, this does appear to be what needs to be done in this particular situation.

But insofar as the equivalent of placement new versus a pointer cast, no they're not the same. One invokes a constructor, one does not. new always invokes the constructor, whether it's placement new, or not. This is a very important detail, that's not to be overlooked.