Though there are other interesting ways of getting a method reference, there already exists an equivalently straightforward way of doing this.

$ref = \&Class::method;
$instance = new Class;
$ref->( $instance, @args );  # - calls method of Class for the given i
+nstance
[download]

You can use closures:

#!/bin/perl -w
use strict; 

# just a simple package
package obj; 

sub new { return bless {content => $_[0]}; } 
sub print
{ my $self= shift;
  print ref($self), ": ", $self->{content}, " - ", @_, "\n"; 
} 

# now the main stuff
package main; 

my $p;                       # that's your method reference
{
  my $o= obj::new( "toto");  # the normal way: create
  $o->print( "tata");        #                 print

  $p=sub { $o->print(@_); }; # create the closure (an anon sub) 
  $p->( "titi");             # use it to print

  $o= obj::new "foo";        # change the object
  $p->("tutu");              # print using the new object
}

my $o= obj::new "bar";       # the $o used with the closure is not
                             # in scope any more 
$p->("tutu");                # but $p still uses it

[download]

This returns:

obj: toto - tata
obj: toto - titi
obj: foo - tutu
obj: foo - tutu
[download]

Note that as far as convenience goes calling $o->print or $p->print is pretty similar ;--)

you can use the UNIVERSAL::can method:

my $object = Ojbect->new;

# normal call
$object->call();

# get ref

my $ref = $object->can('call');

$ref->($object); # use reference..
[download]

This will also follow normal inheritance rules.

Note: you probably need to use the object you want to call as the first argument, because normal object methods expect $self to be the first arguments. (that's what $object->call() does anyway)...

Many complicated ways of calling the reference to a method have been proposed. This one is easier and straightforward.

$obj->$ref2meth(...paras...);
[download]

See my note on pointers to member functions.

That code lets you say:

use PMF;

my $p = PMF->new('print');

$p->$o(123);       # Call $o->print(123)
$p->$x('a','b');   # Call $x->print('a','b')
$p->$z();          # Call $z->print
[download]

Another stupid way:

use obj;
$o = new obj;
$ref = sub{$o->method(@_)};

#so if you want to call ref:
#&ref('arg1','arg2'[,...]);
[download]

All very kludgy, but you could do something like the following. Remember that the first parameter to an object method must be a reference to an object of the right type.

#!/usr/bin/perl -w
use strict;

package Thing;

sub new {
  bless {}, shift;
}

sub say {
  print "@_[1 .. $#_]\n";
}

package main;

my $thing = Thing->new;

$thing->say('Hello', 'World');

my $say = \&Thing::say;

$say->($thing, 'Goodbye', 'All');
[download]