new und delete modulübergreifend überladen

Hallo, ich habe ein kleines Problem:
Ich will unter Windows die Operatoren new und delete überladen, und zwar so, dass sie in einer eigenen DLL stehen und aller Speicher anderer Module von der DLL reserviert wird (das liegt daran, dass ich Zeiger auf STL-Objekte von meiner EXE an eine andere DLL übergebe und sie die STL-Objekte mit STL-Methoden verändern soll. Doch weil ja dabei mit dem STL-Speicher (der von der EXE reserviert wurde) von der DLL herumgespielt wird, führt das zu crashes, deshalb will ich sämtliche Speicheroperationen über ein drittes Modul ausführen).

Doch wie überlade ich die Operatoren in meiner DLL nun?
Wenn ich die Compiler-Deklarationen (bei VC++ __declspec(dllexport/dllimport)) benutze, um die Operatoren zu importieren oder zu exportieren, meldet der Compiler Fehler wegen 'Neudefinition' der Operatorfunktion.

Wie kann ich nun die Operatoren überladen, sodass sie von allen Modulen genutzt werden????

Vielen Dank,
Till

Knuddlbaer

Geht nicht.

Mal abgesehen davon das C++ keine DLL's oder Windows kennt, wirst Du nicht umher kommen die DLL auf eine einfache Schnittstelle zu begrenzen.

Na toll!!
Was kann ich dann tun, um STL-Objekte von anderen Modulen "anzusprechen"?

als "multithreaded dll" kompilieren?!

WAS als "multithread dll" kompilieren?

In nur einem Module:

extern "C" void* __stdcall __declspec(dllexport) global_malloc(size_t s){
  return malloc(s);
}
extern "C" void __stdcall __declspec(dllexport) global_free(void*p){
  free(p);
}

In allen Modulen:

extern "C" void* __stdcall __declspec(dllexport)global_malloc(size_t);
extern "C" void __stdcall __declspec(dllexport)global_free(void*);
inline void*operator new(size_t s){
  return global_malloc(s);
}
inline void operator delete(void*p){
  global_free(p);
}

Sollte selbst klappen wenn du verschiedene Compiler, ja Sprachen, für dll und exe nimmst.

Eine Alernative wäre:
In allen Modulen:

inline void*operator new(size_t s){
  void(*p)(void*);
  p=malloc(s+4);
  *p=free;
  return p+1;
}
inline void operator delete(void*p){
  void(*f)(void*);
  f=((void(*)(void*))p)-1;
  (*f)(f);
}

PS:Beide ungetested!

Danke, das klingt logisch!
Ich werd's testen.