%copy is just a shallow copy. That means, it shares the references to all { drinks => ... } hashes with %hash. If you want to do a deep copy that copies all values and all referenced data structures, have a look at Storable::dclone:

my %copy = dclone(\%hash);
[download]

should be all you need.

Got it. Thanks!! And I thought I knew perl... Never heard of shallow copies. Anybody knows which perldoc has some material on this? perlref doesn't seem to mention them at all. -rod

You might think of

$hash{a}{drinks}=1; 
$hash{b}{drinks}=2;
[download]

as a single hash, but that's not the case. There are three:

• %hash
• %{ $hash{a} }
• %{ $hash{b} }

+-------+     +----------+    +-----------+    +-------------+
| %hash | +-->| Anon Ref | +->| Anon hash | +->| Anon scalar |
+-------+ |   +----------+ |  +-----------+ |  +-------------+
| a   ----+   | addr   ----+  | drinks  ----+  | 1           |
| b   -----+  +----------+    +-----------+    +-------------+
+-------+  |
           |  +----------+    +-----------+    +-------------+
           +->| Anon Ref | +->| Anon hash | +->| Anon scalar |
              +----------+ |  +-----------+ |  +-------------+
              | addr   ----+  | drinks  ----+  | 2           |
              +----------+    +-----------+    +-------------+
[download]

When you do %copy = %hash (which you wrote as %copy = %{ \%hash }), you are copying the keys and values of %hash. So what are the keys and values of %hash?

>perl -e"$h{a}{d}=1; $h{b}{d}=2; print qq{$_: $h{$_}\n} for keys %h;"
a: HASH(0x22534c)
b: HASH(0x2253a0)
[download]

That's all that's copied, nothing more. It will not make a copy of the referenced value and make a new reference to it. It simply copies the references. You end up with

+-------+     +----------+         +-----------+    +-------------+
| %hash | +-->| Anon Ref |  +----->| Anon hash | +->| Anon scalar |
+-------+ |   +----------+  |      +-----------+ |  +-------------+
| a   ----+   | addr   -----+      | drinks  ----+  | 1           |
| b   -----+  +----------+  |      +-----------+    +-------------+
+-------+  |                |
           |  +----------+  |      +-----------+    +-------------+
           +->| Anon Ref |  |  +-->| Anon hash | +->| Anon scalar |
              +----------+  |  |   +-----------+ |  +-------------+
              | addr   --------+   | drinks  ----+  | 2           |
              +----------+  |  |   +-----------+    +-------------+
                            |  |
+-------+     +NEW-------+  |  |
| %copy | +-->| Anon Ref |  |  |
+-------+ |   +----------+  |  |
| a   ----+   | addr   -----+  |
| b   -----+  +----------+     |
+-------+  |                   |
           |  +NEW-------+     |
           +->| Anon Ref |     |
              +----------+     |
              | addr   --------+
              +----------+
[download]

What you want is to do is to copy referenced values as well, and to do recursively, so that you end up with the following:

+-------+     +----------+    +-----------+    +-------------+
| %hash | +-->| Anon Ref | +->| Anon hash | +->| Anon scalar |
+-------+ |   +----------+ |  +-----------+ |  +-------------+
| a   ----+   | addr   ----+  | drinks  ----+  | 1           |
| b   -----+  +----------+    +-----------+    +-------------+
+-------+  |
           |  +----------+    +-----------+    +-------------+
           +->| Anon Ref | +->| Anon hash | +->| Anon scalar |
              +----------+ |  +-----------+ |  +-------------+
              | addr   ----+  | drinks  ----+  | 2           |
              +----------+    +-----------+    +-------------+

+-------+     +NEW-------+    +NEW--------+    +NEW----------+
| %copy | +-->| Anon Ref | +->| Anon hash | +->| Anon scalar |
+-------+ |   +----------+ |  +-----------+ |  +-------------+
| a   ----+   | addr   ----+  | drinks  ----+  | 1           |
| b   -----+  +----------+    +-----------+    +-------------+
+-------+  |
           |  +NEW ------+    +NEW--------+    +NEW----------+
           +->| Anon Ref | +->| Anon hash | +->| Anon scalar |
              +----------+ |  +-----------+ |  +-------------+
              | addr   ----+  | drinks  ----+  | 2           |
              +----------+    +-----------+    +-------------+
[download]

That's called a "deep copy" because it copies every level of the data structure. In contrast, a simple assignment is called a "shallow copy" because it only copies the immediate value (scalar/hash/array/...).

use strict;
my %hash = ();
$hash{a}{drinks}=1;
$hash{b}{drinks}=2;

my $p = \%hash;
my %copy = %{ $p };

print "ref hash: ", \%hash, "\nref copy: ", \%copy, "\n";
print "values hash: ",join(", ", values %hash), "\nvalues copy: ",join
+(", ", values %copy), "\n";
[download]

copy: ab
hash: ab
ref hash: HASH(0x82ef7d8)
ref copy: HASH(0x82ef928)
values hash: HASH(0x82e0308), HASH(0x82ef788)
values copy: HASH(0x82e0308), HASH(0x82ef788)
[download]

Yup, perfectly clear! Thank you! But I've just realized that I don't how to do one thing... how can I make %hash and %copy be in the same mem location? So that when I add a new key to %copy, %hash also changes. I'm just lazy about working with a ref directly as in

$$p{c}=3;
[download]

or

$p->{c}=3;
[download]

I just want

$copy{c}=3;
[download]

To change the value of %hash.
-rod

For global variables, just do a glob assignment:

*copy = \%hash;
[download]

then, %copy and %hash are the same data structure. Otherwise, that is, for lexical variables, use Data::Alias.

Just so you know, Data::Dumper is part of every perl


#!/usr/bin/perl --

use strict;

my %hash = ();
$hash{a}{drinks}=1;
$hash{b}{drinks}=2;

my $p = \%hash;
my %copy = %{ $p };


use Data::Dumper;
print Dumper( \%hash, \%copy, $p );
__END__
$VAR1 = {
          'a' => {
                   'drinks' => 1
                 },
          'b' => {
                   'drinks' => 2
                 }
        };
$VAR2 = {
          'a' => $VAR1->{'a'},
          'b' => $VAR1->{'b'}
        };
$VAR3 = $VAR1;
[download]

What what you are trying, you need to do a "Deep copy" - plenty of references to that in this monastery, and in CPAN modules.

Update: Corion beat me to the explanation and CPAN references.