What you're doing in the first version is overwriting a copy of the reference:

my %hash = ( all => 'old' );       # simple hash value
foo(\%hash);                       # pass reference to hash

sub foo {                          # recieve reference aliased as $_[0
+]
  my $ref = shift;                 # copy reference to $ref (and throw
+ away the $_[0] alias)
  $ref = { all => 'new' };         # overwrite the copy of $ref
                                   # this creates a *new* hash and a n
+ew reference in $ref
                                   # %hash is not modified
}
[download]

my %hash = ( all => 'old' );       # simple hash value
foo(\%hash);                       # pass reference to hash

sub foo {                          # recieve reference as $_[0]
  my $ref = shift;                 # copy reference to $ref (and throw
+ away $_[0])
  $ref->{ all } = 'new';           # overwrite the value to the key 'a
+ll' 
                                   # in the hash pointed to by $ref (w
+hich is %hash)
}
[download]

The key concept is that a reference only points to a value (under the hood, a reference in perl contains only slightly more information than the memory address of the data structure it's referring to) - it does not "contain" the value itself - so modifying the reference does not change the value it's pointing to - you can use it to modify the referenced data only as long as it's actually pointing to that data.

update: by the way: the fact that parameters to a function are aliased in @_ means you *can* change parameters even without passing them by reference (by assigning to $_[0] et al), but that will a) only work if the parameters are non-constant scalars, b) confuse the heck out of your coworkers.

updated code: diotalevi's right.

A nit, my %h = { ... } with braces is wrong. Use parentheses instead.

This code shows that you were not that precise :-) (Update: See below reply from phaylon, sounds like I have misunderstood what he said, and that was my fault. I up voted both of his posts.)

use strict;
use warnings;
my $ref = {"a" => 1};
print $ref, "\n";
foo($ref);

sub foo {
    my $ref = shift;
    print $ref, "\n";
    $ref = { "all" => "new" };
    print $ref, "\n";
}
[download]

Run it, you will see that the first two print statements print the same addresses, but not the third one.

That's actually what I've meant ;) Though I'm not a native speaker, so I may have screwed it up a byte. I meant it copies the contents of the scalar, the reference. That results in a second reference (in counting refcounts) to the same address.

Sorry to confuse, if I have :)

---

Ordinary morality is for ordinary people. -- Aleister Crowley

Passing doesn't make a copy of the reference; it's the assignment to $x that makes a copy.

sub foo {
  my $ref = shift;

  %$ref = ( all => new );
}
[download]

sub foo {
   $_[0] = { all => "new" };
}
[download]

my %x = (foo => 0, bar => 1);

my $z = $x{foo};
$z = 2;
[download]

my %x = (foo => 0, bar => 1);

$x{foo} = 2;
[download]

Just to rephrase this a little. Scalar variables are containers that hold a value. When you assign to a scalar you throw away the value previously contained and overwrite it with a new value.

References are a scalar value that point at (or refer to) other containers. This should be distinguished from an alias which is just a different textual name for the same container. For instance if you modify the first sub:

sub foo {
  for my $ref ($_[0]) {
    $ref = { all => new };
  }
}
my $hash={};
print $hash,"\n";
foo($hash);
print $hash,"\n";
[download]

$ref is now an alias to $_[0] which is itself automagically an alias to whatever scalar was passed into the subroutine which in this case is the scalar $hash. In this case assigning to $ref inside of the sub is the same as assigning to $hash outside of the sub.

On rereading this it may just cause more confusion, if so I apologise.