view release on metacpan or  search on metacpan

FR/perlobj.pod  view on Meta::CPAN

que cette référence est une valeur en lecture seule, qui ne peut pas être
modifiée en manipulant C<$_[0]> au sein du destructeur. L'objet en lui-même
(i.e. le bidule vers lequel pointe la référence, appelé C<${$_[0]}>,
C<@{$_[0]}>, C<%{$_[0]}> etc.) n'est pas soumis à la même contrainte.

Puisque les méthodes DESTROY peuvent être appelées n'importe quand, il
est important de rendre locale toute variable globale utilisée. En
particulier, localisez C<$@> su vous utiliser C<eval {}> et localisez
C<$?> si vous utiliser C<system> ou les apostrophes inverses.

Si vous vous arrangez pour re-consacrer la référence avant la fin du
destructeur, Perl appellera de nouveau la méthode DESTROY après la fin
de l'appel en cours pour l'objet re-consacré. Cela peut être utilisé
pour une délégation propre de la destruction d'objet, ou pour
s'assurer que les destructeurs dans la classe de base de votre choix
sont appelés. L'appel explicite de DESTROY est aussi possible, mais
n'est habituellement pas nécessaire.

Ne confondez pas ce qui précède avec la façon dont sont détruits les
objets I<CONTENUS> dans l'objet courant. De tels objets seront libérés
et détruits automatiquement en même temps que l'objet courant, pourvu
qu'il n'existe pas ailleurs d'autres références pointant vers eux.

=head2 Résumé

C'est à peu près tout sur le sujet. Il ne vous reste plus qu'à aller
acheter un livre sur la méthodologie de conception orientée objet, et
vous le frapper sur le front pendant les six prochains mois environ.

=head2 Ramasse-miettes à deux phases X<ramasse-miettes> X<garbage collector> X<GC> X<référence circulaire> X<circulaire, référence> X<DESTROY> X<destructeur>

Dans la plupart des cas, Perl utilise un système de ramasse-miettes
simple et rapide basé sur les références. Cela signifie qu'il se
produit un déréférencement supplémentaire à un certain niveau, donc si
vous n'avez pas compilé votre exécutable de Perl en utilisant l'option
C<-O> de votre compilateur C, les performances s'en ressentiront. Si
vous I<avez> compilé Perl avec C<cc -O>, cela ne comptera probablement
pas.

Un souci plus sérieux est que la mémoire inaccessible avec un compteur
de références différent de zéro ne sera normalement pas libérée. Par
conséquent, ceci est une mauvaise S<idée :>

    {
        my $a;
        $a = \$a;
    }

Alors même que la variable $a I<devrait> disparaître, elle ne le peut
pas. Lorsque vous construirez des structures de données récursives, vous
devrez briser vous-même explicitement l'auto-référence si vous ne voulez pas
de fuite de mémoire. Par exemple, voici un noeud auto-référent comme ceux
qu'on pourrait utiliser dans une structure d'arbre S<sophistiquée :>

    sub new_node {
        my $self = shift;
        my $class = ref($self) || $self;
        my $node = {};
        $node->{LEFT} = $node->{RIGHT} = $node;
        $node->{DATA} = [ @_ ];
        return bless $node => $class;
    }

Si vous créez de tels noeuds, ils ne disparaîtront pas (actuellement)
à moins que vous ne brisiez leur auto-référence vous-même (en d'autres
termes, cela ne doit pas être considéré comme une caractéristique et
vous ne devriez pas compter là-dessus).

Ou presque.

Lorsqu'un thread de l'interpréteur se termine finalement (habituellement au
moment où votre programme se termine), une libération de la mémoire plutôt
coûteuse, mais complète par marquage et nettoyage est effectuée, tout ce qui a
été alloué par ce thread est détruit. C'est essentiel pour pouvoir supporter
Perl comme un langage embarqué et multithread. Par exemple, ce programme
montre le ramassage des miettes en deux phases de S<Perl :>

    #!/usr/bin/perl
    package Subtle;

    sub new {
        my $test;
        $test = \$test;
        warn "CREATING " . \$test;
        return bless \$test;
    }

    sub DESTROY {
        my $self = shift;
        warn "DESTROYING $self";
    }

    package main;

    warn "starting program";
    {
        my $a = Subtle->new;
        my $b = Subtle->new;
        $$a = 0;  # break selfref
        warn "leaving block";
    }

    warn "just exited block";
    warn "time to die...";
    exit;

Exécuté en tant que F</tmp/test>, la sortie suivante est S<produite :>

    starting program at /tmp/test line 18.
    CREATING SCALAR(0x8e5b8) at /tmp/test line 7.
    CREATING SCALAR(0x8e57c) at /tmp/test line 7.
    leaving block at /tmp/test line 23.
    DESTROYING Subtle=SCALAR(0x8e5b8) at /tmp/test line 13.
    just exited block at /tmp/test line 26.
    time to die... at /tmp/test line 27.
    DESTROYING Subtle=SCALAR(0x8e57c) during global destruction.

Avez-vous remarqué le "global destruction"E<nbsp>? C'est le ramasse-miettes du
thread en train d'atteindre l'inaccessible.

Les objets sont toujours détruits, même lorsque les références normales ne le