operator new überladen

otze

ich hab mir eine streamklasse gebastelt,und hab dazu nun noch ein Interface aufgebaut.Die stream klasse erstellt im konstruktor eine virtuelle datei mittel malloc.
da es im ernstfall vorkommen kann, dass malloc keinen speicher mehr reservieren kann, oder die datei aber zu groß ist,brauch ich noch eine 2. stream klasse,die sich genauso verhält aber aus der datei läd,aber das ist hier jetzt nicht thema

wenn malloc innerhalb des konstruktors versagt,soll das sofort ausserhalb gecatcht werden,und ein alternativ stream eingesetzt.
ich hab auch schon ne konkrete idee, doch hab ich noch 1-2 sachen, auf die ich nich komme..

//innerhalb der streamklasse
/*muss hier static hin?*/void* operator new(size_t Type_size)throw(malloc_failed){
    try
    {
        Virtualfile* fileclass=new Virtualfile(/*ich weis nich wie ich im new operator die parameter übermitteln kann*/);
        return fileclass;    
    }
    catch(malloc_failed)
    {
        Virtualstream* streamclass=new Virtualstream(//auch hier müssen wieder die parameter hin);
        return streamclass;
    }    
}
//aufruf
Vstream* File=new Virtualfile(parameter1,parameter2);

ist das so durchsetzbar, oder gäbs probleme?

Shlo

was haben die Ctor-Parameter mit operator new zutun? static kann angegeben werden, muss aber nicht. Ein überladener operator new/delete ist immer eine statische Methode, auch wenn nicht explizit als static deklariert.

otze

in der hilfe steht, dass man noch weitere parameter einfügen kann, nur die frage ist wie und wo-.-

groovemaster

Ich hatte mir mal ne Klasse für Memory Tracing gebastelt. Da hab ich new und delete überladen. Das ganze sah dann ungefähr so aus:

inline void* operator new(size_t size, const char* file, int line, const char* function)
{
	...
}

Und der Aufruf sieht folgendermassen aus:

int* buf = new(__FILE__, __LINE__, __func__) int[100];

Nur mal so ne Frage, wieso malloc? new wirft doch automatisch eine Ausnahme wenn der Speicher ausgeht. bad_alloc glaub ich heist die.

Shade Of Mine

otze schrieb:

ist das so durchsetzbar, oder gäbs probleme?

Naja, es ist blödsinn.
Allokiere einfach ganz normal mit operator new Speicher, und wirf ne Exception wenn operator new 0 returned...

Oder du verwedendest gleich new.

new zu überladen macht nur dann sinn, wenn du den Speicher irgendwie effizienter besorgen kannst.

btw: du hast das überladen von new noch nicht ganz verstanden

Jover

Shade Of Mine schrieb:

Allokiere einfach ganz normal mit operator new Speicher, und wirf ne Exception wenn operator new 0 returned...

in etwas so

Foo* foo = new(nothrow) Foo;
if (foo == NULL)
    throw std::bad_alloc;

Shade Of Mine

Jover schrieb:

in etwas so

Foo* foo = new(nothrow) Foo;
if (foo == NULL)
    throw std::bad_alloc;

Wieso? Habe ich das etwa gesagt?

Ich sagte mit operator new und selber ne Exception werfen, oder gleich mit new

Kleiner Tipp:

Foo* foo=operator new(sizeof(Foo));
if(!foo) throw bad_alloc();
new(foo) Foo(x);

//gleich

Foo* foo=new Foo(x);

Jover

OOP's, sorry. habs nicht richtig gelesen.
(Blödes ostern)