eigentlich bin ich ja aus der C-Welt, aber manchmal komme ich an C++ nicht vorbei. Aus diesem Grund habe ich mal eine Frage an die C++-Kenner.

Ich entwickle momentan ein eigenes Apache-Module, Apache stellt zum entwickeln von Modulen die APR zur verfügung. Diese Combo aus Schnittstelle und Framework benutzt ein malloc/free-like Memory-Management, aber auf Pool-Basis.

Kurz: Beim aufruf von apr_malloc muss ein Pool übergeben werden, also ein Context-bezogener "Memory-Manager".

Das sieht dann ggf. so aus:

int8_t foobar(APR_Request* request)
{
    uchar8_t* buffer = apr_malloc(request->pool, sizeof(uchar8_t) * 128);

    /* Mach was mit "buffer". */

    /* Optional kann apr_free aufgerufen werden für "buffer", 
       jedoch nicht umbedingt nötig, da "pool" von "request" 
       nach der zerstörung von Request auch freigegebe wird. 

       apr_free(buffer);
     */

    return 0;
}

Soviel zur Kurzerklärung vom Pooling in Apache. Das ist auch ne ganz feine Sache, jedoch ist die APR rein C. Würde ich jetzt eine Klasse bzw. ein Array von Klassen mit apr_malloc aufrufen, wird natürlich nicht der c'tor der Klasse aufgerufen, da dies nur der operator new kann.

Jetzt ist meine Frage: wie kann ich einen Context-bezogenen "pool", also Parameter, an operator new übergeben? Da das ganze Thread-sicher sein muss kann ich nicht einfach eine globale Funktion anlegen á la "setUsedPoolForOperatorNew".

Auch die expliziete Implementierung von operator new in Klassen geht nicht, da diese Context-unabhängig sein müssen und erst durch new einem speziellen Context zugeordnet werden.

Aus diesem Grund dachte ich an etwas in dieser Richtung:

// Ein Array mit 4 Instanzen von "Foobar" erstellen auf dem pool vom Context "request".
Foobar* foos = new (request->pool)[4] Foobar();

Ist so etwas möglich, wenn ja: Wie? Wenn das nicht möglich ist, gibt es eine thread-sichere alternative wo die Klassen Context-unabhängig sind?

Viele Grüße,
euer C++-Coder

Hier noch was genaueres hierzu:
http://www.parashift.com/c++-faq-lite/dtors.html#faq-11.14

Link

ja mit dem Destruktor habe ich noch 1-2 Probleme, da ich für meinen Pool eine "clear"-Methode benötige und dort keine Klassennamen mehr kenne für einen expliziten Aufruf des Destruktors.

But anyway, ich möchte delete einen weiteren Parameter übergeben, jedoch führt ein manueller Aufruf von delete den Destruktor nicht mehr aus, warum?

class Foobar
{
public:
	Foobar()
	{
		printf("%s\n", __FUNCTION__);
	}

	~Foobar()
	{
		printf("%s\n", __FUNCTION__);
	}
};

void * operator new(size_t size, size_t& dummy)
{
	printf("%s\n", __FUNCTION__);

	++dummy;

	return malloc(size);
}

void operator delete(void *p, size_t& dummy)
{
	printf("%s\n", __FUNCTION__);

	--dummy;

	free(p);
}

int main()
{
	size_t dummy = 0;

	Foobar* x = new (dummy) Foobar();
	operator delete(x, dummy); // Es wird kein d'tor aufgerufen?
}

Viele Grüße,
euer C++-Coder

ja mit dem Destruktor habe ich noch 1-2 Probleme, da ich für meinen Pool eine "clear"-Methode benötige und dort keine Klassennamen mehr kenne für einen expliziten Aufruf des Destruktors.

Wie wärs mit einem Template?

C++-Coder schrieb:

But anyway, ich möchte delete einen weiteren Parameter übergeben, jedoch führt ein manueller Aufruf von delete den Destruktor nicht mehr aus, warum?

Weil er das nie tut. operator delete gibt nur Speicher frei. delete hingegen ruft den Destruktor und operator delete auf.

Suche mal nach "placement new"
damit kannst du new sagen, wo es das Objekt konstruieren soll, ohne dass es Speicher anfordert. D.h. du holst dir erst Speicher aus dem Pool und dann darauf ein placement new

Hier noch was genaueres hierzu:
http://www.parashift.com/c++-faq-lite/dtors.html#faq-11.14

Danke Dir für den Link, das ist eine sehr interessante Lektüre.