Object as hash key

Question

Is it possible to use an object as a hash key?

For example, the following code allows me to use an instance of MyClass as a key but when I iterate over the keys and attempt to invoke the get_value method, I get the error:

Can't locate object method "get_value" via package "MyClass=HASH(0x12a4040)" (perhaps you forgot to load "MyClass=HASH(0x12a4040)"?)

package MyClass;
use strict;

sub new
{
    my $class = shift;
    my $self = {
        _value => shift
    };
    bless $self, $class;
    return $self;
}

sub get_value {
    my($self) = @_;
    return $self->{_value};
}

my %hash = ();
%hash->{new MyClass(1)} = 0;
%hash->{new MyClass(2)} = 1;

for my $key (keys %hash)
{
    print $key->get_value;
}

Answer 1

Anything used as a hash key is stringified. So when using your object as a hash key, you're only getting a string representation of it and not the actual object itself.

The real question is, why in the world would you want to do this?

Also, the syntax for assigning values to a hash is $hash{key} = $val; the arrow is used when you're dealing with a hash reference.

If you want to associate objects with some other value, one way would be to use an array of hashes, e.g.

my @foo;
push @foo, { obj => MyClass->new( 1 ), val => 0 };
push @foo, { obj => MyClass->new( 2 ), val => 1 };

Then you could call $foo[0]{obj}->get_value();

If you just want your objects to be able to return some unique per-instance ID, you could add a method that takes advantage of Scalar::Util's refaddr operator:

use Scalar::Util 'refaddr';

sub unique_id { 
    my $self = shift;
    return refaddr $self;
}

...

$hash{MyClass->new(1)->unique_id} = 0;

For more: perlobj, perldata, perlreftut, Scalar::Util

Answer 2

By default, all hash keys in Perl are strings, so what is happening in you code (which has other problems as well), is you are converting the object to a string and storing the string.

In general, if you want to use a object as a key, the simplest way to do it is to use two data structures, one that holds your objects (an array), and another that maps the objects to some values (a hash). It is also possible to create a tied hash which will support objects as keys, but in general, tied hashes are going to be slower than simply using two data structures.

The standard module Tie::RefHash provides a mechanism for using objects (and other references) as hash keys (that work properly when you get them back).

use Tie::RefHash;
tie my %hash, 'Tie::RefHash';

$hash{MyClass->new(1)} = 0;  # never use the indirect object syntax
....