in reply to Do subroutine variables get destroyed?

The first 2 posts are completely on target, re: reference counting.

As a demo, I re-wrote your a1 sub and added an a2 sub.

Rather than assigning the hash reference in the subroutine to the "global" variable, I would recommend returning the hash reference from the sub as shown in recoded sub a1.

Like in C, it is possible to pass a "pointer", the hash reference to a sub as shown in sub a2. The memory previously used by sub a1 is "re-used", same struct is modified. If "my $href" goes out of lexical scope, its memory will be recovered and reused by Perl.

#!/usr/bin/perl use strict; use warnings; use Data::Dumper; # a cool core module # that dumps any structure my $href = a1(); #hash reference returned from sub print "v1=$href->{'v1'}\n"; #dot operator not needed print Dumper $href; a2($href); print Dumper $href; exit(0); sub a1 { my %hash; $hash{v1} = 10; $hash{v2} = 20; return \%hash; # %hash memory will "live" due to # reference counting } sub a2 { my ($href) = @_; $href -> {v1} = 30; #quotes are ok but not needed $href -> {'v2'} = 40; return; } __END__ v1=10 $VAR1 = { 'v2' => 20, 'v1' => 10 }; $VAR1 = { 'v2' => 40, 'v1' => 30 };

Replies are listed 'Best First'.
Re^2: Do subroutine variables get destroyed?
by bt101 (Acolyte) on May 08, 2016 at 16:00 UTC
    Thanks everyone, those are great answers. I gather that if the reference variable is pointed to a new item, then the old item to which it pointed no longer has any references to it and it will be destroyed.
      ... if the reference variable is pointed to a new item, then the old item to which it pointed no longer has any references to it and it will be destroyed.

      An unreferenced referent (i.e., one having a ref count of 0) will be marked for garbage collection and will eventually be destroyed.


      Give a man a fish:  <%-{-{-{-<

      Yes, that is correct.

      Consider what happens with my re-coded sub a1,

      my $href = a1(); $href = a1();
      The first call makes a hash and returns a reference to it. The second call also makes a hash and returns a reference to it. However after the second call, the reference to the first hash is now "lost" as it was replaced by a reference to the second hash that was generated. The memory for the first hash is then recylced because its reference count is zero and there is no way for the program to access that data anymore.

      Of course in a "real" example, probably there are some parameters to sub a1 so that it generates a different kind of hash on the second call. One reason to do this might be in a GUI interface where a1() winds up being say a "button factory". If the references returned are kept in scope, say in an array, then each button is a distinct thing.

      For the most part, Perl memory management does the "right thing" under the covers and is transparent to you. There are of course special considerations with certain types of data structures and when making truly huge structures in the sub.