Re: recursive reference delete subroutine

[Zed_Lopez]

Simply

undef $ref;

should do it for you -- if its referent's reference count drops to zero, its memory will be freed automatically (and so on, recursively.)

Keep in mind, the memory is only freed for reuse by your program, not to the OS, but that shouldn't be hurting you here.

So my guesses would be that either you have a memory leak, or that you just plain don't have enough memory for your current algorithm with the data you're using, and you'll have to be cleverer about the algorithm -- no amount of undeffing or deleting is going to save you.

[chromatic]

I disagree; I think that answer merely hopes for a solution instead of answering the question directly.

use Test::More tests => 2;

sub undef_hash
{
    my $ref = shift;
    undef $ref;
}

sub assign_hash
{
    my $ref = shift;
    %$ref   = ();
}

my $hash_one = { qw( foo bar baz quux ) };
undef_hash( $hash_one );
is( keys %$hash_one, 2,
    'undef on hash reference should not clear it' );

my $hash_two = { qw( foo bar baz quux ) };
assign_hash( $hash_two );
is( keys %$hash_two, 0,
    'assigning empty list to hash reference should clear it' );

Update: Ahh, I misunderstood. Yes, replacing the subcall will probably work.

[Zed_Lopez]

I was presuming the OP would replace the calls to deleteref with just the undef. You're right, of course, that making a copy of the reference in a subroutine and undeffing that is a no-op.

use Test::More tests => 2;

sub deleteref {
    my $h = shift;
    undef $h;
}

my $c = {d => 3};

deleteref($c);
is( keys %$c, 1,
    'undef on copy of hashref in a subroutine should not clear it' );


undef $c;
is( keys %$c, 0,
    'undef on hash reference, not a copy of it in a subroutine, should
+ clear it' );