Post semaphore in shared memory crashes

Question

I have 2 processes:

• producer: creates an Transaction object inside a shared memory then waiting for consumer to read the data. The waiting is done via a semaphore which is a member of Transaction
• consumer: reads the Transaction object created by producer and tells producer the reading is done by posting semaphore in Transaction object.

Consumer is able to read the data from shared memory but it crashes when it tries to post semaphore.
What's wrong with this implementation?

//producer
#include <string>
#include <semaphore.h>
#include <cstddef>
#include <sys/mman.h>
#include <sys/stat.h>        /* For mode constants */
#include <fcntl.h>           /* For O_* constants */
#include <unistd.h>
#include <iostream>

constexpr char g_shared_mem_name[]="/our_shared_mem_new";

class Transaction
{
public:
    virtual ~Transaction() = default;
    Transaction(const uint32_t f_count) : m_count{f_count}{}
    
    sem_t m_sem;

    uint32_t m_count{0};
};

void* createSharedMem(const char *f_name, const size_t f_size) {
    int fd = shm_open(f_name, O_CREAT | O_RDWR, S_IRUSR | S_IWUSR);
    if (fd != -1) {
        // A new shared memory object initially has zero length.
        // The size of the object can be set using ftruncate.  
        // The newly allocated bytes of a shared memory object are
        // automatically initialized to 0
        if (ftruncate(fd, f_size) == -1) {
            return nullptr;
        }

        return mmap(NULL, f_size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0 );
    }
    else {
        return nullptr;
    }
}

int main()
{   
    void * shared_mem = createSharedMem(g_shared_mem_name, sizeof(Transaction));
    if ( shared_mem ) 
    {
        Transaction* shared_obj = new(shared_mem) Transaction(2022);
        
        if( sem_init(&shared_obj->m_sem,1,0) == -1) {
            std::cerr << "Unable to initialize m_sem_init\n";
        }

        //waiting for consumer to finish reading data
        if( sem_wait(&shared_obj->m_sem) == -1) {
            std::cerr << "Error on waiting for semaphore\n";
        }
    }
    else {
        std::cerr << "Unable to create shared object\n";
    }

    shm_unlink(g_shared_mem_name);
    
    return EXIT_SUCCESS;
}

Consumer

#include <string>
#include <semaphore.h>
#include <cstddef>
#include <sys/mman.h>
#include <sys/stat.h>        /* For mode constants */
#include <fcntl.h>           /* For O_* constants */
#include <unistd.h>
#include <iostream>

constexpr char g_shared_mem_name[]="/our_shared_mem_new";

class Transaction
{
public:
    virtual ~Transaction() = default;
    Transaction(const uint32_t f_count) : m_count{f_count}{}
    
    sem_t m_sem;

    uint32_t m_count{0};
};

void* openSharedMem(const char * f_name, const size_t f_size) {
    int fd = shm_open(f_name, O_RDONLY, 0);
    if( fd != -1 ) {
        return mmap(NULL, f_size, PROT_READ, MAP_SHARED, fd, 0 );
    }
    else {
        return nullptr;
    }
}

int main()
{   
    void* shared_mem = openSharedMem(g_shared_mem_name, sizeof(Transaction));
    if (shared_mem) {
        Transaction * m_inst = (Transaction*)shared_mem;
        std::cout << "value of cnt:" << m_inst->m_count << std::endl;
        
        //crash here
        if (sem_post(&m_inst->m_sem) == -1) {
            std::cerr << "Unable to post semaphore\n";
        }
    }
    else {
        std::cerr << "Unable to open shared object\n";
    }

    return EXIT_SUCCESS;
}

Output

value of cnt:2022
Segmentation fault (core dumped)