Ich möchte eine MemoryManager Klasse schreiben, die Heap Allokationen zentralisiert. D.h. man kann sollte im Code nirgends mehr new aufrufen, sondern alle Allokationen nur noch per MemoryManager Klasse vornehmen. Den allokierten Blöcken will ich Metainfos wie z.B. einen beschreibenden String anhängen (hat vor allem Debuggründe).

Jetzt frage ich mich, wie ich das am besten implementiere.
Meine 2 ersten Ideen waren:
1. Templates, also vielleicht sowas:

Foo* f = MemoryMng.allocate<Foo>("my foo object");
char* c = MemoryMng.allocateArray<char>(1000);

Das Problem das ich hier habe: Wie übergebe ich Werte an Konstruktoren von Klassen? Also wenn Foo zb. 3 Paramter kriegt, wie übergebe ich die an den Foo Ctor?

2. Wegen der Ctor Argument Problematik kam ich auf Ansatz 2: placement new:

Foo* f = MemoryMng.allocate(sizeof(Foo), "my foo object"); // allokiert sizeof(foo) bytes. Kein Ctor Aufruf!
f = new (f) Foo(a, b, c);

Das sollte so ja klappen, oder? Muss ich beim placement new irgendwas beachten bzgl. Alignment?

Was findet ihr besser bzw. gäbe es noch eine bessere Lösung?

Außerdem kann man benutzerdefinierte operator new() mit beliebigen Parametern definieren, so daß dann sowas möglich ist:

Foo* f = new("my foo") Foo(x,y,z);

Ich würde mich bei so einer Klasse an std::allocator<> orientieren (falls du das noch nicht kennst - das verwenden die STL-Container, um Speicher zu reservieren).

Außerdem kann man benutzerdefinierte operator new() mit beliebigen Parametern definieren, so daß dann sowas möglich ist:

Foo* f = new("my foo") Foo(x,y,z);

Hm, ok, das klingt ja schon recht gut.
Darf ich dann in meinem globalen void operator new(size_t size, const char* s); nicht mehr new benutzen, oder? (also das standard new ohne parameter gibts dann nicht mehr?)
Muss ich dann in meinem globalen new malloc() benutzen? Aber dann wird ja nicht der Ctor aufgerufen? Oder ist der new Operator NUR für die Speicherbeschaffung gut und macht der NIE Ctor Aufrufe (es heißt ja immer: Malloc ruft keinen Ctor auf, new schon)

PS: Mit welchem Compiler arbeitest du eigentlich? Beim MSVC erinnere ich mich noch an #define new DEBUG_NEW als Diagnosehilfe für Speicherlecks.

void* operator new(size_t size, const char* s);

dann kann ich ihn doch so aufrufen:

Foo* f = new ("Hallo") Foo(2,3, "test");

Das ist aber jetzt kein placement new? Auf einer Seite habe ich nämlich gelesen, dass Placement new so aussieht: new (expression) Type(params);
Nach dieser Definition wäre aber mein Aufruf ein placement new. Wann überschreibe ich jetzt placement new und wann einfach nur den globalen new operator?

Noch eine Randfrage: Wenn operator new void* zurückgibt, wieso muss ich dann bei Foo* f = new("hallo") Foo; eigentlich nicht downcasten auf Foo*?

Das placement-new ist ein Spezialfall des überschriebenen operator new . Es ist etwa so definiert:

void* operator new(size_t, void* ptr) { return ptr; }

Man kann es also ausnutzen, um in einen schon vorhandenen Speicherplatz ein Objekt zu konstruieren (anders bekommt man den Konstruktor nicht aufgerufen, das kann nur new ).

Ich verstehe nicht den Unterschied zwischen placement new und einer globalen überschreibung von operator new.
Wenn ich den operator new so neu definiere:

void* operator new(size_t size, const char* s);

dann kann ich ihn doch so aufrufen:

Foo* f = new ("Hallo") Foo(2,3, "test");

Das ist aber jetzt kein placement new? Auf einer Seite habe ich nämlich gelesen, dass Placement new so aussieht: new (expression) Type(params);
Nach dieser Definition wäre aber mein Aufruf ein placement new.

Das ist alles eine Frage der Definition - wenn du alle new-Varianten mit Zusatzparametern als Placement new bezeichnest, ist das eins. Wenn du nur die In-Place Konstruktion als Placement new bezeichnest ( Foo* p = malloc(sizeof(p));new(p)Foo(x,yz); ), ist es keins.

Und wie ipsec schon erklärte: operator new arbeitet mit nacktem Speicher - hinter den Kulissen ruft new erst den entsprechenden operator new() auf, erledigt dann den Downcast und ruft den Konstruktor auf. Dieses Verhalten kannst du nicht beeinflussen - du kannst nur festlegen, woher der verwendete Speicher kommt.

Ich weiß jetzt also, dass es ein keyword new gibt und einen operator new. Operator new kümmert sich nur um die Speicherallokierung. Keyword new ruft operator new auf, danach den Ctor und kümmert sich auch um den Downcast.

Was mir hingegen nicht klar ist:
1. Das hier ist ja placement new:

void* p = malloc(sizeof(Foo));
Foo* f = new (p) Foo(2);

Hier erzeugt new also NICHT neuen Speicher sondern legt Foo nur in den vorhandenen Speicher. Kann ich das überhaupt überschreiben? Wie sollte so ein überschriebener globaler placement new überhaupt aussehen?

2. ipsec meinte, placement new ist nur ein Spezialfall eines operator new. Das versteh ich nicht, denn placement new ist ja doch was anderes.
Hier ruft keyword new erst operator new auf und der legt Speicher an. Danach Ctor Aufruf etc.

Foo* f = new ("Hallo") Foo(2);

Das hier sieht ähnlich aus, aber ist was anderes:

Foo* f = new (p) Foo(2);

Denn hier ruft keyword new operator new auf aber dieses mal wird operator new KEINEN Speicher allokieren, sondern sofort das Objekt im vorhandenen Speicher initialisieren. Bei einem placement new macht das keyword new also was anderes als bei einem standard operator new. Wie wird das unterschieden?

1. Wenn du C++0x hast, geht so etwas:

namespace memory
{
template<typename T, typename... Args> T *allocate(Args... args)
{
    return new T(args...);
}
}

2. Wenn nicht, geht je nach Anwendungsfall immer noch ein Define:

#define NEW_1(Type, ...) CreateObj1(new Type(__VA_ARGS__))
#define NEW_2(call) CreateObj1(new call)

template<typename T> T *CreateObj1(T *ptr)
{
    register_pointer_in_debug_database(ptr);
    return ptr;
}

Darf ich dann in meinem globalen void operator new(size_t size, const char* s); nicht mehr new benutzen, oder? (also das standard new ohne parameter gibts dann nicht mehr?)

Natürlich gibt's den normalen operator new dann noch, du kannst den Aufruf einfach weiterleiten (ohne den const char* Parameter natürlich, sonst wäre der Aufruf ja rekursiv).

Allerdings halte ich das ganze Vorhaben für Unfug. Aber jeder wie er meinst.

#define new new(__FILE__,__LINE__)

machen.