In der Informatik ist die Gegenstand-Lebenszeit (oder Lebenszyklus) eines Gegenstands in der objektorientierten Programmierung die Zeit zwischen einer Entwicklung eines Gegenstands (auch bekannt als instantiation oder Aufbau), bis der Gegenstand nicht mehr verwendet wird, und zerstört oder befreit wird.

In der objektorientierten Programmierung (OOP) ist die Bedeutung, Gegenstände zu schaffen, viel feiner als das einfache Zuteilen von Räumen für Variablen. Erstens ist das, weil, im OOP Paradigma, die Lebenszeit jedes Gegenstands dazu neigt, sich weiter zu ändern, als im Fall in der herkömmlichen Programmierung. Es gibt viele feine Fragen, einschließlich ob der Gegenstand, lebendig im Prozess der Entwicklung, und bezüglich der Ordnung betrachtet werden, initialisierenden Code zu nennen. In einem Sinn kann die Entwicklung vor dem Anfang des Programms geschehen, wenn Gegenstände in ein globales Spielraum gelegt werden.

Das Schaffen von Gegenständen

Im typischen Fall ist der Prozess wie folgt:

• berechnen Sie die Größe eines Gegenstands - die Größe ist größtenteils dasselbe als diese der Klasse, aber kann sich ändern. Wenn der fragliche Gegenstand aus keiner Klasse abgeleitet wird, aber von einem Prototyp statt dessen ist die Größe eines Gegenstands gewöhnlich die der inneren Datenstruktur (ein Kuddelmuddel zum Beispiel), der seine Ablagefächer hält.
• Zuteilung - das Zuteilen des Speicherraums mit der Größe eines Gegenstands plus das Wachstum später, wenn möglich, um im Voraus zu wissen
• verbindliche Methoden - das wird gewöhnlich entweder zur Klasse des Gegenstands verlassen, oder wird in der Absendungszeit aufgelöst, aber dennoch ist es möglich, dass einige Gegenstand-Modelle Methoden in der Entwicklungszeit binden.
• einen initialisierenden Code (nämlich, Konstrukteur) der Superklasse nennend
• das Benennen eines initialisierenden Codes der Klasse, die wird schafft

Jene Aufgaben können sofort vollendet werden, aber werden manchmal unfertig verlassen, und die Ordnung der Aufgaben kann ändern und kann mehrere fremde Handlungsweisen verursachen. Zum Beispiel, im Mehrerbe, welches Initialisieren des Codes erst genannt werden sollte, ist eine schwierige Frage zu antworten. Jedoch sollten Superklassenkonstrukteure vor Unterklasse-Konstrukteuren genannt werden.

Es ist ein kompliziertes Problem, jeden Gegenstand als ein Element einer Reihe zu schaffen. Einige Sprachen (z.B. C ++) verlassen das Programmierern.

Das Berühren von Ausnahmen in der Mitte der Entwicklung eines Gegenstands ist besonders problematisch, weil gewöhnlich sich die Durchführung von werfenden Ausnahmen auf gültige Gegenstand-Staaten verlässt. Zum Beispiel gibt es keine Weise, einen neuen Raum für einen Ausnahme-Gegenstand zuzuteilen, als die Zuteilung eines Gegenstands davor wegen eines Mangels am freien Raum auf dem Gedächtnis gescheitert hat. Wegen dessen sollten Durchführungen von OO Sprachen Mechanismen zur Verfügung stellen zu erlauben, Ausnahmen zu erheben, selbst wenn es knappen Vorrat von Mitteln gibt, und Programmierer oder das Typ-System sicherstellen sollten, dass ihr Code vor der Ausnahme sicher ist. Bemerken Sie, dass das Fortpflanzen einer Ausnahme zu kostenlosen Quellen wahrscheinlich ist (aber nicht teilen Sie sie zu). Jedoch, im Gegenstand orientierte Programmierung, kann Gegenstand-Aufbau immer scheitern, weil das Konstruieren eines Gegenstands die Klasse invariants gründen sollte, die häufig für jede Kombination von Konstrukteur-Argumenten nicht gültig sind. So können Konstrukteure immer Ausnahmen erheben.

Das abstrakte Fabrikmuster ist ein Weg zu decouple eine besondere Durchführung eines Gegenstands aus dem Code für die Entwicklung solch eines Gegenstands.

Entwicklungsmethoden

Die Weise, Gegenstände zu schaffen, ändert sich über Sprachen. Auf einigen klassenbasierten Sprachen, eine spezielle als ein Konstrukteur bekannte Methode, ist dafür verantwortlich, den Staat eines Gegenstands gültig zu machen. Gerade wie gewöhnliche Methoden können Konstrukteure überladen werden, um es zu machen, so dass ein Gegenstand mit verschiedenen angegebenen Attributen geschaffen werden kann. Außerdem ist der Konstrukteur der einzige Platz, den Staat von unveränderlichen Gegenständen zu setzen. Ein Kopie-Konstrukteur ist ein Konstrukteur, der einen (einzelnen) Parameter eines vorhandenen Gegenstands desselben Typs wie die Klasse des Konstrukteurs nimmt, und eine Kopie des als ein Parameter gesandten Gegenstands zurückgibt.

Andere Programmiersprachen, wie Ziel-C, haben Klassenmethoden, die Methoden des Konstrukteur-Typs einschließen können, aber auf das bloße Realisieren von Gegenständen nicht eingeschränkt werden.

C ++ und Java sind dafür kritisiert worden, genannt Konstrukteur der Konstrukteure-a nicht zur Verfügung zu stellen, muss immer denselben Namen wie die Klasse haben. Das kann problematisch sein, wenn der Programmierer zwei Konstrukteure mit denselben Argument-Typen z.B versorgen will, um einen Punkt zu schaffen, protestieren entweder von den kartesianischen Koordinaten oder von den Polarkoordinaten, von denen beide durch zwei Schwimmpunkt-Zahlen vertreten würden. Ziel-C kann dieses Problem überlisten, in dem der Programmierer eine Punkt-Klasse mit Initialisierungsmethoden zum Beispiel schaffen kann, und. In C ++ kann etwas Ähnliches mit statischen Mitglied-Funktionen getan werden.

Ein Konstrukteur kann sich auch auf eine Funktion beziehen, die verwendet wird, um einen Wert einer markierten Vereinigung besonders auf funktionellen Sprachen zu schaffen.

Das Zerstören von Gegenständen

Es ist allgemein der Fall, dass nachdem ein Gegenstand verwendet wird, wird es auswendig entfernt, um Platz für andere Programme zu machen, oder protestiert, um den Platz dieses Gegenstands zu nehmen. In der Größenordnung davon, um zu geschehen, wird von einer Zerstörungsmethode dieser Gegenstand gefordert. Das Zerstören eines Gegenstands wird irgendwelche Verweisungen auf den Gegenstand verursachen, ungültig zu werden.

Ein destructor ist eine genannte Methode, wenn ein Beispiel einer Klasse gelöscht wird, bevor das Gedächtnis deallocated ist. Bemerken Sie, dass in C ++ ein destructor wie ein Konstrukteur nicht überladen werden kann, kann. Es muss keine Argumente haben. Ein destructor braucht Klasse invariants nicht aufrechtzuerhalten.

Auf Müll-Sammeln-Sprachen können Gegenstände zerstört werden, wenn sie durch den laufenden Code nicht mehr erreicht werden können. Beispiele davon sind Pythonschlange und Java. Pythonschlange hat destructors, und sie sind fakultativ. Auf vielen Müll-Sammeln-Sprachen, finalizers (die davor genannt werden, wird einem Gegenstand Müll-gesammelt), werden statt destructors verwendet, da der Punkt der Müll-Sammlung auf diesen Sprachen nicht voraussagbar ist. Das Beispiel von diesen schließt Java und Ruby ein.

Beispiele

C ++

Klasse Foo

{\

//Das ist der Prototyp der Konstrukteure

Publikum:

Foo (interne Nummer x);

Foo (interne Nummer x, interne Nummer y);//Überlasteter Konstrukteur

Foo (const Foo &old);//Kopieren Konstrukteur

~Foo ;//Destructor

};

Foo:: Foo (interne Nummer x)

{\

//Das ist die Durchführung von

//der Ein-Argument-Konstrukteur

}\

Foo:: Foo (interne Nummer x, interne Nummer y)

{\ //Das ist die Durchführung von

//der Zwei-Argumente-Konstrukteur

}\

Foo:: Foo (const Foo &old)

{\ //Das ist die Durchführung von

//der Kopie-Konstrukteur

}\

Foo:: ~Foo

{\

//Das ist die Durchführung des destructor

}\

int Hauptsache

{\

Foo foo (14);//nennen den ersten Konstrukteur

Foo foo2 (12, 16);//nennen überladenen Konstrukteur

Foo foo3 (foo);//nennen den Kopie-Konstrukteur

kehren Sie 0 zurück;

//destructors hat Umgekehrt-Ordnung herbeigerufen

//hier, automatisch

}\

</Quelle>

Java

Klasse Foo{\

Publikum Foo (interne Nummer x)

{\

//Das ist die Durchführung von

//der Ein-Argument-Konstrukteur

}\

Publikum Foo (interne Nummer x, interne Nummer y)

{\ //Das ist die Durchführung von

//der Zwei-Argumente-Konstrukteur

}\

Publikum Foo (Foo alt)

{\ //Das ist die Durchführung von

//der Kopie-Konstrukteur

}\

öffentliche statische leere Hauptsache (Schnur [] args)

{\

Foo foo = neuer Foo (14);//nennen den ersten Konstrukteur

Foo foo2 = neuer Foo (12, 16);//nennen überladenen Konstrukteur

Foo foo3 = neuer Foo (foo);//nennen den Kopie-Konstrukteur

//Müll-Sammlung geschieht unter den Deckel, und Klassen werden zerstört

}\}\</Quelle>

C#

namespace ObjectLifeTime

{\Klasse Foo{\

Publikum Foo

{\ //Das ist die Durchführung von

//Verzug-Konstrukteur

}\ Publikum Foo (interne Nummer x) {\ //Das ist die Durchführung von //der Ein-Argument-Konstrukteur }\

~Foo

{\ //Das ist die Durchführung von

//der destructor

}\ Publikum Foo (interne Nummer x, interne Nummer y) {\ //Das ist die Durchführung von //der Zwei-Argumente-Konstrukteur }\ Publikum Foo (Foo alt) {\ //Das ist die Durchführung von //der Kopie-Konstrukteur }\

öffentliche statische leere Hauptsache (Schnur [] args)

{\

Foo defaultfoo = neuer Foo ;//nennen Verzug-Konstrukteur

Foo foo = neuer Foo (14);//nennen den ersten Konstrukteur Foo foo2 = neuer Foo (12, 16);//nennen überladenen Konstrukteur Foo foo3 = neuer Foo (foo);//nennen den Kopie-Konstrukteur }\

}\

}\</Quelle>

Ziel-C

1. Import

@interface-Punkt: Gegenstand

{\

doppelter x;

doppelter y;

}\

//Das sind die Klassenmethoden; wir haben zwei Konstrukteure erklärt

+ (Punkt *) newWithX: (doppelter) andY: (doppelt);

+ (Punkt *) newWithR: (doppelter) andTheta: (doppelt);

//Beispiel-Methoden

- (Punkt *) setFirstCoord: (doppelt);

- (Punkt *) setSecondCoord: (doppelt);

/* Da Punkt eine Unterklasse des allgemeinen Gegenstands ist

* Klasse, wir gewinnen bereits allgemeine Zuteilung und Initialisierung

* Methoden, +alloc und-init. Für unsere spezifischen Konstrukteure

* können wir diese von diesen Methoden machen wir haben

* geerbt.

*/

@end

@implementation-Punkt

- (Punkt *) setFirstCoord: (doppelter) new_val

{\

x = new_val;

}\

- (Punkt *) setSecondCoord: (doppelter) new_val

{\

y = new_val;

}\

+ (Punkt *) newWithX: (doppelter) x_val andY: (doppelter) y_val

{\

//Kurz geschriebene Klassenmethode automatisch zuzuteilen und

//führen Sie spezifische Initialisierung durch.

zurückkehren

}\

+ (Punkt *) newWithR: (doppelter) r_val andTheta: (doppelter) theta_val

{\

//Anstatt dasselbe als das obengenannte durchzuführen, können wir hinterhältig

//verwenden Sie dasselbe Ergebnis der vorherigen Methode

kehren Sie [Zurück spitzen newWithX:r_val andY:theta_val] an;

}\@end

interne Nummer

Haupt(Leere)

{\

//Konstruktionen zwei Punkte, p und q.

Spitzen Sie an, dass *p = [NewWithX:4.0 andY:5.0] anspitzen;

Spitzen Sie an, dass *q = [NewWithR:1.0 andTheta:2.28] anspitzen;

//... Programm-Text....

//Wir werden mit p, sagen wir, so beendet, befreien ihn.

//Wenn p mehr Gedächtnis für sich zuteilt, kann zu brauchen

//überreiten Sie die freie Methode des Gegenstands um zu rekursiv

//das Gedächtnis des freien p. Aber das ist nicht der Fall, so können wir gerade

[p frei];

//... mehr Text...

[q frei];

kehren Sie 0 zurück;

}\</Quelle>

Pythonschlange

Klassensteckdose:

def __ init __ (selbst, remote_host):

self.connection = connectTo (remote_host)

def senden (selbst):

# senden Daten

def recv (selbst):

# erhalten Daten

def f :

s = Steckdose ('example.com')

s.send ('Test')

geben Sie s.recv zurück

</Quelle>

Steckdose wird bei der folgenden Müll-Sammlung herum geschlossen, weil alle Verweisungen darauf verloren worden sind.

Siehe auch

• Resource Acquisition Is Initialization (RAII), eine Annäherung an die Betriebsgegenstand-Lebenszeit