Problem Copying Hash of Arrays (REUSED_ADDRESS)

[IvaPopova]

Hello,

Consider this

 
use strict;
use Data::Dumper;
 
my %hash1=(a=>[1,1],
        b=>[2,2],
        c=>[3,3],);
 
my %hash2=%hash1;
 
$hash1{a}[0]=10;
 
print Dumper(%hash2);
 

The problem is that when copying %hash1 into %hash2, the values of %hash2 are just a references to
the SAME arrays in %hash1, so changing an array element in %hash1 changes the respective element
in the new %hash2. But I want to store the old value of %hash1 into %hash2.
In a first attempt to solve that problem, I come with that :

use Data::Dumper;
use strict;
my %hash1=(a=>[1,1],
        b=>[2,2],
        c=>[3,3],);
 
my %hash2=();
while ( my ($key,$val)= each %hash1) {
  my @arr=@{$val};
  $hash2{$key}=\@arr;
}
 
$hash1{a}[0]=10;
print Dumper(%hash2);
 

but it's quite ugly.
I've also found that can surround the problem by assigning not a new value to the array (see: $hash1{a}[0]=10; )
but assigning a whole new array like this : $hash1{a}=[10,10];

But I still can't understand why the arrays are "copied" with the same address into %hash2 and
how I can store a %HoA into another %Hoa ...

please help

[miller]

This is basically functioning as it shoud. If you want complete clones of each of the data structures inside the %hash, then you'll have to copy each of them. The easiest way to accomplish this would be to make a subroutine that recursively operated on arrays and unreferenced each element. The only function that it's important to be familiar with to accomplish this is ref.

http://perldoc.perl.org/functions/ref.html

Here is the code and function that I quickly through together from your example.

use strict;
use Data::Dumper;
 
my %hash = (
    a    => [1,1],
    b    => [2,2],
    c    => [3,3],
);
 
my %copy = %hash;
my %clone = clone(%hash);
 
$hash{a}[0]=10;
 
print 'copy - ' . Dumper(\%copy);
print 'clone - ' . Dumper(\%clone);
 
 
sub clone {
    map { ! ref() ? $_ : ref eq 'HASH' ? {clone(%$_)} : ref eq 'ARRAY' ? [clone(@$_)] : die "$_ not supported" } @_;
}
 

Also, just as a stylistic note, I find it much better if I only pass scalars to Dumper. In this instance that means passing a reference to the hashes you want to explore instead of the hashes themselves. You'll find the output to be much cleaner in my opinion.

Good luck.

[KevinADC]

another possibility:

use Data::Dumper;
 use Storable qw/dclone/;
my %hash1=(a=>[1,1],
        b=>[2,2],
        c=>[3,3],);
 
my $hash2 = dclone(\%hash1);
 
$hash1{a}[0]=10;
 
print Dumper(\$hash2,\%hash1);

$hash2 will be a copy only of %hash1, but the structure of $hash2 is a little different in that $hash2 is a reference to a hash of arrays instead of a hash of arrays like %hash1 is.

[IvaPopova]

Really appreciate your help... Thanks