Klasse wieder frei geben?

Hi,

ich habe bei meiner Zusatzarbeit für die Schule ein problem:

Ich erstelle eine Klasse und initialisiere sie mit new:

meineKlasse *x = new x(3,4);

soweit kein problem

Aber das Freigeben, klar ich kanns so frei geben:

delete x;[/b]
doch so solls laut meinem Lehrer nicht sein, sondern ich sollen eine art "Release"-Funktion einbauen.

das soll dann so aussehen:
[cpp]
x->Release();
x = NULL;

Wie kann man sowas machen?

ich kann doch schlecht sowas in eine Release-Funktion schreiben:

void meineKlasse::Release (){
    if (this)
    delete this;
}

?

Wie geht sowas, ich mein, bei DirectX gibt es ja auch sowas? Wie wurde das da gemacht?

otze

void meineKlasse::Release (){
    delete this;
}

und fertig. mehr ist da nicht

//edit
der test ob this existiert muss nicht sein, die codezeile verschleiert höchstens fehler,und das kann böse enden.

und was wenn es nicht mit new initialisiert wurde? dann gibt es doch einen crash? Oder was ist wenn die klasse schon vorher frei gegeben wurde? Sollte man dafür eine bool-variable benutzen alá bool isReleased_; ?

otze

wenn die klasse nicht mit new erstellt wure, brauchst du dir ums release keine sorgen zu machen, das musst du dann garnicht mehr aufrufen.

und wer zwei mal hintereinander release aufruft, hat einen programmcrash verdient.

Naja dummheit gibts überall, drum sollte man sich irgendwie absichern.

Wäre das mit bool denn ne gute idee oder gäb es eine bessere? "Bitte nix mit Smartpointern"

Walli

otze schrieb:

und wer zwei mal hintereinander release aufruft, hat einen programmcrash verdient.

Im Prinzip schon, aber ich würde mich an der Stelle zumindest durch ein ASSERT absichern. Kostet ja nichts.

otze

Naja dummheit gibts überall, drum sollte man sich irgendwie absichern.

der code sollte aber nicht dumm geschrieben sein. die dummheit sollte das programm nur nicht bei falscher eingabe zum absturz bringen ;).

fakt ist, dass du durch einen absturz bei release() weist, dass irgendwo in deinem programm irgendwas falsch gelaufen ist. wenn du release absicherst, fehlt dir diese kleine möglichkeit, den code debuggen zu können. Denn ein programm, dass nur falsche werte ausgibt ohne abzustürzen ist sehr sehr schwer zu debuggen.

evilissimo

*** schrieb:

meineKlasse *x = new x(3,4);

Sollte das evtl.

meineKlasse *x = new meineKlasse(3,4);

heißen?

MfG

Dein Lehrer spinnt, delete ist genau dafür gedacht.

Ne Release-Funktion macht höchstens dann Sinn, wenn du intern reference counting machst. Das heißt, dass du das Objekt irgendwo in den Speicher legst, an mehreren Stellen Referenzen darauf verlangst und das Objekt dann zerstört werden soll, wenn du keine Referenz mehr darauf hältst. Und selbst dann ist es eigentlich überholter Stil, weil du nicht wirklich wissen kannst, ob du das reference counting für die Klasse immer brauchst. Sinnvoller ist es, das in einen sog. "smart pointer" auszulagern, der einen Verweis auf das eigentliche Objekt enthält, das Interface eines Pointers zur Verfügung stellt und das reference counting für dich übernimmt. Wenns dich interessiert, schau dir mal das an: http://www.boost.org/libs/smart_ptr/smart_ptr.htm und konkret http://www.boost.org/libs/smart_ptr/shared_ptr.htm

groovemaster

Wenn's schon eine Release Funktion sein soll (was ich nicht nachvollziehen kann , wozu gibts denn delete), dann reicht die Funktion von otze imo vollkommen aus. Wenn das Objekt nicht mehr gültig ist, weil kein Speicher dafür zur Verfügung steht oder weil es auf null zeigt, darf Release auch nicht aufgerufen werden, oder du provozierst UB. Da hilft auch ein ASSERT nicht weiter.
Wieso will denn dein Lehrer eine Release Funktion überhaupt? Wollt ihr DirectX nachprogrammieren?
Wenn schon kein offenes delete, dann sind Smart Pointer für sowas doch viel schöner.

otze

release ist meiner meinung nach nur in so einem fall sinnig:

class Factory;
class Object{
        Object(){};
        ~Object(){...}
        friend Factory;
    public:
        //...
        void release(){...}
};
class Factory{
    //...
    public:
        Object* create(){...}
};
int main(){
    Factory foo;
    Object* bar=foo.create();
    bar->doSth();
    bar->release();
}

wenns nich ganz fehlerfrei ist, nich ausrasten, ich bin müde und brauche den post

vorteil: sowohl die funktionen zum erstellen, als auch die zum löschen sind perfekt vorm benutzer weggekapselt, und er kann nicht so einfach im internen system rumschnüffeln