Problem mit Klassen "Steuerelement"

Question

also hier ist die Sache .. Ich habe ein Objekt, das verantwortlich ist, ein anderes Objekt zu erstellen, kann dieses erstellte Objekt zerstört werden oder nicht (das ist abhängig vom Benutzer). Der Trick besteht darin, dass das "creator" -Objekt erneut aufgerufen wird, und wenn das andere Objekt nicht gelöscht wurde, kann diese Klasse dieses Objekt nicht erneut erstellen, aber wenn das andere Objekt gelöscht wurde, muss diese Klasse erneut erstellt werden und die Schleife wird fortgesetzt.

ich versuchte 2 Lösungen: Globale Variable als "Flagge", es hat gut funktioniert, aber ich habe für den Einsatz globale Variable geröstet; Zweitens sollte der Destruktor einen Wert zu diesem Flag zurückgeben, aber ich kann nicht von Destruktor zurückkehren.

Kennen Sie einen anderen Weg als die globale Variable?

Wirklich appretiate die Aufmerksamkeit, Prost.

Answer 1

Sie haben keine Programmiersprache angegeben, daher nehme ich Perl (mit Moo als OO-Toolkit) an.

Hier ist eine mögliche Implementierung von dem, was Sie beschreiben:

use v5.14.0; 
use warnings; 

package Item { 
    use Moo; 

    has _owner => (
     is  => 'ro', 
     weak_ref => 1, 
     clearer => 1, 
    ); 

    sub detach { 
     my ($self) = @_; 
     if (my $owner = $self->_owner) { 
      $self->_clear_owner; 
      $owner->_clear_item; 
     } 
    } 

    sub BUILD { 
     my ($self) = @_; 
     say "!! constructing $self"; 
    } 

    sub DEMOLISH { 
     my ($self) = @_; 
     say "!! destroying $self"; 
    } 
} 

package Owner { 
    use Moo; 

    has item => (
     is  => 'lazy', 
     clearer => '_clear_item', 
    ); 
    sub _build_item { 
     my ($self) = @_; 
     return Item->new(_owner => $self); 
    } 
} 

my $owner = Owner->new; 
say "owner = $owner"; 
say "(1) owner->item = ", $owner->item; 
say "(2) owner->item = ", $owner->item; 
say "entering block {"; 
{ 
    my $item = $owner->item; 
    say " (3) owner->item = $item"; 
    $item->detach; 
    say " detached item = $item"; 
} 
say "} leaving block"; 
say "(4) owner->item = ", $owner->item; 
say "owner is still = $owner"; 

Wenn ich diesen Code ausführen, erzeugt es die folgende Ausgabe:

owner = Owner=HASH(0x23e52f8) 
!! constructing Item=HASH(0x23e4950) 
(1) owner->item = Item=HASH(0x23e4950) 
(2) owner->item = Item=HASH(0x23e4950) 
entering block { 
    (3) owner->item = Item=HASH(0x23e4950) 
    detached item = Item=HASH(0x23e4950) 
!! destroying Item=HASH(0x23e4950) 
} leaving block 
!! constructing Item=HASH(0x23eb328) 
(4) owner->item = Item=HASH(0x23eb328) 
owner is still = Owner=HASH(0x23e52f8) 
!! destroying Item=HASH(0x23eb328) 

Die Idee ist, dass die Owner Klasse eine hat item Attribut (das eine Instanz der Item Klasse speichert). Dieses Attribut ist faul, daher wird es nur bei Bedarf erstellt (das erste Mal, wenn Sie es verwenden).

Wie Sie durch einen Blick auf den owner->item Linien 1, 2 und 3 keine neuen Objekte sind so konstruiert sehen: $owner erinnert sich an seine item.

Es ist jedoch möglich, item explizit zu löschen, indem Sie $owner->item->detach aufrufen. Dies ist möglich, weil jede Instanz von Item ein (optionales) _owner Attribut besitzt; d.h. jeder Gegenstand erinnert sich an seinen Besitzer. Dies ist eine schwache Referenz, denn sonst hätten wir einen Referenzzyklus (Besitzer hält den Gegenstand am Leben, Gegenstand hält den Besitzer am Leben).

Wenn wir $item->detach anrufen, entfernt sich $item automatisch von seinem Besitzer (wenn es noch einen hat). Sie wird dann automatisch gelöscht, sobald ein anderer Verweis darauf verloren geht (im Beispiel geschieht dies, wenn die lokale Variable $item am Ende ihres Blocks nicht mehr existiert).

$owner, nachdem sie in den Ausgangszustand zurückgesetzt wurde, dann automatisch neu erstellt ein neues item das nächste Mal benötigt wird.