ich habe eine DLL geschrieben, die ich in verschiedenen Programmen benutzen und auch auf einen gemeinsamen Speicherbereich der DLL zugreifen möchte.
Also die benutzenden Programme sollen auf einen Datensatz zugreifen.

Es sieht aber nun so aus, als ob jeweis eine neue Instanz angelegt wird, mit natürlich einem eigenen Datensatz.

Aus meinem Hauptprogramm

void __fastcall TForm2::FormShow(TObject *Sender)
{
	HMODULE hDLL = LoadLibrary("DLL_TestProjekt.dll");

	if (hDLL >0) {

		iTest = (int*) GetProcAddress(hDLL, "_TestCount");
		Label1->Caption = IntToStr(iTest);
		long* pHilf = (long*) (GetProcAddress(hDLL, "_pMainFormDlg"));
		MF_Dlg = (TMainFormDlg*) *pHilf;
		Label1->Caption = IntToStr(MF_Dlg);
	}
}

Aus meiner DLL

__declspec( dllexport ) int	TestCount = 37;
__declspec( dllexport ) TMainFormDlg*	pMainFormDlg = NULL;

int WINAPI DllEntryPoint(HINSTANCE hinst, unsigned long reason, void* lpReserved)
{
	Application->CreateForm(__classid(TMainFormDlg), &MainFormDlg);
	pMainFormDlg = MainFormDlg;
	pMainFormDlg->pTestCount = &TestCount;
	return 1;
}

TestCount und pMainFormDlg beziehen sich immer auf eine Instanz, des die DLL benutzenden Hauptprogrammes. Und genau das will ich nicht.

Danke

// shareddata.hpp
#ifndef _UCL_SHAREDDATA_HPP
#define _UCL_SHAREDDATA_HPP

#include <windows.h>
#include <typeinfo>
#include <cstring>
#include <cstdio>
#include <new>

namespace ucl
{

namespace win
{

template <typename T> class SharedData
{
private:
    class wrapper_t
    {
    private:
        unsigned refcnt;

        wrapper_t (void)
         : refcnt (1)
        {}
        ~wrapper_t (void)
        {}

    public:
        T obj;

        static void create (void* mem)
        { new (mem) wrapper_t; }
        void addRef (void)
        { ++refcnt; }
        void removeRef (void)
        {
            if (--refcnt == 0)
            {
                this->~wrapper_t ();
                return true;
            }
            return false;
        }
    };

    HANDLE hSharedData;
    wrapper_t* _data;

public:
    SharedData (const char* name);
    ~SharedData (void);

    T* get (void) { return &(_data->obj); }
    T* operator -> (void) { return &(_data->obj); }
    T& operator * (void) { return _data->obj; }

    const T* get (void) const { return &(_data->obj); }
    const T* operator -> (void) const { return &(_data->obj); }
    const T& operator * (void) const { return _data->obj; }
};

template <typename T>
SharedData <T>::SharedData (const char* name)
{
    unsigned nl, tl;
    char* buf;
    const char* tn;
    bool existing;

    tn = typeid (T).name ();
    nl = std::strlen (name);
    tl = std::strlen (tn);
    buf = new char[nl + tl + 7];
    std::sprintf (buf, "ucl;%s;%s", tn, name);
    hSharedData = CreateFileMapping (INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0,
        sizeof (wrapper_t), buf);
    existing = (GetLastError () != ERROR_ALREADY_EXISTS);
    delete [] buf;

    if (!hSharedData)
        return;

    _data = (wrapper_t*) MapViewOfFile (hSharedData, FILE_MAP_ALL_ACCESS, 0, 0, 0);
    if (existing)
        _data->addRef ();
    else
        wrapper_t::create (_data);
}

template <typename T>
SharedData <T>::~SharedData (void)
{
    _data->removeRef ();
    UnmapViewOfFile (_data);
    CloseHandle (hSharedData);
    _data = NULL;
}

} // namespace win

} // namespace ucl

#endif // _UCL_SHAREDDATA_HPP

Verwenden kannst du es wie folgt:

// dllmain.cpp

#include "shareddata.hpp"

struct my_shared_data_t
{
    int foo;

    my_shared_data_t (void)
     : foo (0)
    {}
    ~my_shared_data_t (void)
    {}
};

ucl::win::SharedData <my_shared_data_t> msd ("Ein_Name_für_deine_DLL");

void someDLLFunction (void)
{
    msd->foo = 12;
}