Shared Memory

#include <boost/interprocess/windows_shared_memory.hpp>
#include <boost/interprocess/mapped_region.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/thread.hpp>
#include <boost/bind.hpp>

#include <cstring>
#include <cstdlib>
#include <string>
#include <iostream>

#include <windows.h>

#define SIZE 10000

using namespace boost;
using namespace boost::interprocess;
using namespace std;

class CSharedMemory
{

public:
    enum eMode{ Mode_None,Mode_Parent, Mode_Child };

    CSharedMemory(eMode Mode,string name) : m_IsOpen(false), m_Mode(Mode)
    {

        m_ParentSHM     =   NULL;
        m_ParentRegion  =   NULL;
        m_ChildSHM      =   NULL;
        m_ChildRegion   =   NULL;
        m_Thread        =   NULL;

        // Setzen der Informationen
        m_Name = name;

        if(Mode == Mode_None) { return; }

        // Initialisieren des Threads, und des SM
        m_IsOpen = Init();
    }
    ~CSharedMemory()
    {
        if(m_Thread)
        {
            m_Thread->interrupt();

            if(m_Thread->joinable())
                m_Thread->join();

            delete m_Thread;
        }

        if(m_ParentSHM)
            delete m_ParentSHM;
        if(m_ParentRegion)
            delete m_ParentRegion;

        if(m_ChildSHM)
            delete m_ChildSHM;
        if(m_ChildRegion)
            delete m_ChildRegion;

        m_IsOpen = false;
    }

    bool IsOpen() { return m_IsOpen; }

    bool Write(const char *data,size_t size)
    {
        if(!m_IsOpen) return false;

        if(m_Mode == Mode_Parent)
        {
            if(size > m_ParentRegion->get_size()) return false;

            memset(m_ParentRegion->get_address(),0,m_ParentRegion->get_size());
            memcpy(m_ParentRegion->get_address(),data,size);

            return true;
        }
        else if(m_Mode == Mode_Child)
        {
            if(size > m_ChildRegion->get_size()) return false;

            memset(m_ChildRegion->get_address(),0,m_ChildRegion->get_size());
            memcpy(m_ChildRegion->get_address(),data,size);

            return true;
        }
        return false;
    }

    eMode GetMode() { return m_Mode; }
protected:
    virtual void OnMessage(char *data,size_t size)
    {
        if(m_Mode == Mode_Parent)
            cout << "Nachricht von Child: " << data << endl;
        else if(m_Mode == Mode_Child)
            cout << "Nachricht von Parent: " << data << endl;

        return;
    }

    void Thread()
    {
        while(1)
        {
            // "Unterbrechungs" Punkt
            boost::this_thread::interruption_point();

            if(m_Mode == Mode_Parent)
            {
                if(((char *)(m_ChildRegion->get_address()))[0] != NULL)
                {
                    char *data = new char[m_ChildRegion->get_size()];
                    memset(data,NULL,m_ChildRegion->get_size());

                    memcpy(data,m_ChildRegion->get_address(),m_ChildRegion->get_size());

                    OnMessage(data,m_ChildRegion->get_size());

                    delete [] data;

                    memset(m_ChildRegion->get_address(),0,m_ChildRegion->get_size());
                }
            }
            else if(m_Mode == Mode_Child)
            {
                if(((char *)(m_ParentRegion->get_address()))[0] != NULL)
                {
                    char *data = new char[m_ParentRegion->get_size()];
                    memset(data,NULL,m_ParentRegion->get_size());

                    memcpy(data,m_ParentRegion->get_address(),m_ParentRegion->get_size());

                    OnMessage(data,m_ParentRegion->get_size());

                    delete [] data;

                    memset(m_ParentRegion->get_address(),0,m_ParentRegion->get_size());
                }
            }

            boost::this_thread::sleep(boost::posix_time::millisec(10));
        }
    }
private:
    eMode                   m_Mode;
    bool                    m_IsOpen;

    windows_shared_memory   *m_ParentSHM;
    mapped_region           *m_ParentRegion;

    windows_shared_memory   *m_ChildSHM;
    mapped_region           *m_ChildRegion;

    boost::thread           *m_Thread;
    string                  m_Name;

    bool Init()
    {
        if(m_Mode == Mode_Parent)
        {
            try { m_ParentSHM = new windows_shared_memory(create_only,(m_Name + "_Parent").c_str(),read_write,SIZE); }
            catch(...) { return false; }

            try { m_ParentRegion = new mapped_region(*m_ParentSHM,read_write); }
            catch(...) { return false; }

            try { m_ChildSHM = new windows_shared_memory(create_only,(m_Name + "_Child").c_str(),read_write,SIZE); }
            catch(...) { return false; }

            try { m_ChildRegion = new mapped_region(*m_ChildSHM,read_write); }
            catch(...) { return false; }

            try { m_Thread = new boost::thread(boost::bind(&CSharedMemory::Thread,this)); }
            catch(...) { return false; }

            return true;
        }
        else if(m_Mode == Mode_Child)
        {
            try { m_ParentSHM = new windows_shared_memory(open_only,(m_Name + "_Parent").c_str(),read_write); }
            catch(...) { return false; }

            try { m_ParentRegion = new mapped_region(*m_ParentSHM,read_write); }
            catch(...) { return false; }

            try { m_ChildSHM = new windows_shared_memory(open_only,(m_Name + "_Child").c_str(),read_write); }
            catch(...) { return false; }

            try { m_ChildRegion = new mapped_region(*m_ChildSHM,read_write); }
            catch(...) { return false; }

            try { m_Thread = new boost::thread(boost::bind(&CSharedMemory::Thread,this)); }
            catch(...) { return false; }

            return true;
        }

        return false;

    }
};

int main(int argc, char *argv[])
{
    CSharedMemory *Parent = new CSharedMemory(CSharedMemory::Mode_Parent,"Memory");
    CSharedMemory *Child  = new CSharedMemory(CSharedMemory::Mode_Child,"Memory");

    char *str = "hallo welt!";

    while(1)
    {
        if(GetAsyncKeyState(VK_NUMPAD1))
        {
            Parent->Write(str,strlen(str));
        }
        if(GetAsyncKeyState(VK_NUMPAD2))
        {
            Child->Write(str,strlen(str));
        }
        else if(GetAsyncKeyState(VK_NUMPAD3))
        {
            delete Child;
            delete Parent;
            break;
        }
        Sleep(50);
    }

    getchar();
    return 0;
}