Once you "stringify" a reference, you have fundamentally changed the nature of the data that the scalar refers to. It's now a string, not a reference. As for your second question, no, you can not get at the data once associated with the reference. You play around with Devel::Pointer, but that shouldn't be used for anything serious.

You also asked if the object the reference pointed two was destroyed after the interpolation. The answer is "no". Interpolating a reference does not affect the reference count, nor does assigning the interpolation affect it.

Cheers,
Ovid

Join the Perlmonks Setiathome Group or just click on the the link and check out our stats.

The only problem I have with that is why you would do something like this anyway:

my $ref = Object->new();
$ref = "$ref";   # overwrite $ref: destroy object
[download]

my $ref = Object->new();
my $refstring = "$ref";  # keep object in $ref
[download]

#!/usr/bin/perl -w
use strict;
use vars qw($ref);

$ref = [1,2,3,4];
print join(',',@$ref)."\n";

my $string = "$ref";
#print join(',',@$string)."\n";  # this does not work

my $getref = unstringify($string) || die "Cannot find ref!";
print join(',',@$getref)."\n";

sub unstringify {
    # works only on globals in package main !
    # but you could also use another hash 
    # ( instead of %main:: )
    my $string = shift;
    for (keys %{main::}) {
        my $value;
        next unless $value = ${${main::}{$_}};
        next unless ref($value);
        next unless $value eq $string;  # implicit stringification
        return $value;
    }
    return;
}
[download]

This is ofcourse a terribly hack, you'd be a lot better of if you store your references somewhere where you can retrieve them easier.

-- 
Joost       downtime n. The period during which a system
            is error-free and immune from user input.
[download]

my $ref2 = $ref; # not "$ref"
[download]

jeffa

L-LL-L--L-LL-L--L-LL-L--
-R--R-RR-R--R-RR-R--R-RR
B--B--B--B--B--B--B--B--
H---H---H---H---H---H---
(the triplet paradiddle with high-hat)

After such an interpolation happens - is the object the reference is/was pointing to destroyed if this was the last reference.

In your particular code, the answer would be now as $ref variable that also stores the reference is still 'effective' or within the scope. However, if you had something like this:

my $ref2;
{ # Block A
  my @aha = (1,2,3,4,5);

  my $ref = \@aha;

  $ref2="$ref";
}

print "@$ref\n";
print ref($ref), "  $ref\n";
print ref($ref2),"  $ref2\n";
[download]

 use Devel::Pointer;

 my @aha = (1,2,3,4,5);
 my $ref = \@aha;
 my $ref2 = "$ref";

 my ($addr) = ($ref2 =~ m/\(\0\x(\d+)\)/);
 $real_ref = deref($addr);

 # $real_ref must now point to the @aha array..
[download]

$"=q;grep;;$,=q"grep";for(`find . -name ".saves*~"`){s;$/;;;/(.*-(\d+)
+-.*)$/;
$_=["ps -e -o pid | "," $2 | "," -v "," "];`@$_`?{print"+ $1"}:{print"
+- $1"}&&`rm $1`;
print$\;}
[download]