Als Übung wollte ich den Operator new Überladen, um so Heapspeicher umzuallokieren, statt neuen Speicher anzufrordern und umzukopieren,
aber leider ist mir aufgefallen, dass das bei meinem VC++ 8 Compiler einen Fehler macht...

#include <iostream>

void *operator new[](size_t, void*);

int main(int args, char *arg[])
{
	int *a = new int[3];
	*a = 123;
	a = new(a) int[40];
	a[26] = 4;
}

void *operator new[](size_t size, void* oldPtr)
{
	void* newPtr;
	return ( newPtr = realloc(oldPtr, size) ) ? newPtr : NULL;
}

weil es ja einen placement new Operator gibt, der von der Argumentenliste mit meinem new übereinstimmt und weil der inline ist, ist der Code auch direkt in der Library eingebunden, weshalb das so nicht geht (ich glaube beim g++ ist das genau so)

Daher hab ich nur 3 fragen:

1. Wie kann ich meinen Operator new nun doch nutzen?
2. Wieso gibt es den placement new überhaupt?
(ich mein so, als ob man ihn nicht nachprogrammieren könnte, ist es ja nicht...)
3. wieso muss der inline sein? ich glaube kaum das man das Ding sehr oft benutzt

2. Wieso gibt es den placement new überhaupt?

Nunja, der "originale" new-Operator macht im Prinzip zwei Dinge: Speicher allokieren und Konstruktor(en) aufrufen. Der Placement-new-Operator ruft halt nur den/die Konstruktor(en) auf dem entsprechenden Speicherstück auf. Das kann man nämlich sonst nicht

Nunja, der "originale" new-Operator macht im Prinzip zwei Dinge: Speicher allokieren und Konstruktor(en) aufrufen. Der Placement-new-Operator ruft halt nur den/die Konstruktor(en) auf dem entsprechenden Speicherstück auf.

Thx jetz wirds mir klar, auch wenn ich vieleicht als halber Neuling noch nicht begreife, wieso man nur einen Konstruktor aufrufen will.

Das kann man nämlich sonst nicht

Doch und zwar so:

void *operator new(size_t, void*);

int main(int args, char *arg[])
{
	class A {public: A(){};};
	A* a = new A;
	a = new(a) A;
}

/* inline */ void *operator new(size_t size, void* p){ return p; }

weil es ja einen placement new Operator gibt, der von der Argumentenliste mit meinem new übereinstimmt und weil der inline ist, ist der Code auch direkt in der Library eingebunden, weshalb das so nicht geht (ich glaube beim g++ ist das genau so)

Der placement-operator new der Standardbibliothek darf nicht redeklariert (und -definiert) werden, in jedem Falle muss aber auch <new> eingebunden werden, bevor operator new in irgendeiner Form global überladen oder ersetzt wird. Den Default-placement-Operator kann man also nicht ersetzen, es ist aber möglich, placement-operatoren mit anderer Signatur bereitzustellen. Das kann sogar ein template sein, z.B.

#include <new>

template<typename T>
void* operator new[](size_t, T*);

Der Defaultplacement-Operator benutzt void* - falls du irgendwann mal über einen placement-Aufruf der Standardbibliothek gestolpert bist, wirst du wahrscheinlich einen Cast gesehen haben, damit eben sicher genau dieser Default-Operator aufgerufen wird.

3. wieso muss der inline sein?

So eine Bedingung existiert nicht.

Grundsätzlich wird das, was du hier versuchst, wahrscheinlich trotzdem nicht funktionen, jedenfalls bewegst du dich hier in einer ziemlichen dunklen Ecke der Sprache.
Ohne Angabe eines Initialisierers haben PODs einen unbestimmten Anfangswert, bevor ihnen etwas anderes zugewiesen wird (5.3.4/15, siehe auch 8.5/9). Das heißt gerade nicht - oder jedenfalls kenne ich keine Stelle des Standards, die das suggerieren würde - dass dieser unbestimmte Wert etwas mit dem Inhalt des Speichers an dieser Stelle vor dem Aufruf von new zu tun hat. Zur Illustration:

T x,y; // irgendein POD
memcpy(&y,&x,sizeof y);
new(&x) T;
assert(memcmp(&x,&y,sizeof x)==0); // könnte fehlschlagen

Das könnte zum Beispiel in Debug-Situationen von Nutzen sein. Ein anderer Grund dürfte in 3.10/15 zu finden sein, andernfalls wäre placement-new die ideale Methode um den berüchtigten union-cast doch noch legal durchführen zu können.

Ich hab aber auch noch einen anderen Weg gefunden placement new zu "redeklariert".

#define __PLACEMENT_VEC_NEW_INLINE //deaktiviert inline operator new[](size_t, coid*)
#include <iostream>

void* operator new[](size_t, void*);

int main(int args, char *arg[])
{
        int *a = new int;
	*a = 22;
	a = new(a) int[44];
	a[42] = 123;
	std::cout << *a;
	std::cin.get();
}

void* operator new[](size_t size, void* oldPtr)
{
	void* newPtr;

	return ( newPtr = realloc(oldPtr, size) ) ? newPtr : NULL;
}

new.cpp: In function ‘void* operator new [](size_t, void*)’:
new.cpp:16: error: redefinition of ‘void* operator new [](size_t, void*)’
/usr/include/c++/4.2/new:106: error: ‘void* operator new [](size_t, void*)’ previously defined here

Klapt wohl nur bei VC++

Zunächt einmahl thx @all ich war schon eher der Meinung, der pleacment Operator sei Sinnlos.

Von sinnlos kann keine Rede sein, ich brauche es z.B. gerade. Aber für Deinen Fall ist es wahrscheinlich einfach ungeeignet.

void* operator new[](size_t size, void* oldPtr)
{
	void* newPtr;

	return ( newPtr = realloc(oldPtr, size) ) ? newPtr : NULL;
}

Was soll eigentlich dieser Code? Der ist ziemlich konfus. Folgender Code ist doch inhaltlich absolut identisch:

void* operator new [](size_t size, void* old) {
    return realloc(old, size);
}