This is generally true, but there is an example in Conway's book where he uses AUTOLOAD for accessor methods, but creates a new method on the fly, so that AUTOLOAD is only called the first time that a particular method is used.

The code looks like this (note use of no strict to allow symbolic references in a strictly (no pun intended) controlled manner.)

Should probably point out that this isn't actually Damien Conway's code, but a slightly changed version that I hacked up.

sub AUTOLOAD {
  no strict 'refs';
  my ($self, $val) = @_;
  my ($name) = $AUTOLOAD =~ m/.*::(\w*)/;

  *{$AUTOLOAD} = sub { return @_ > 1 ?
             $_[0]->{$name} = $_[1] :
               $_[0]->{$name}};

  return defined $val ? $self->{$name} = $val : $self->{$name};
}
[download]

Cool, this is a very good idea for accessors. Thanks davorg (and Damien). I think I will start tweaking the code we have here to match.

But for our problem mentioned before (the DB result objects) the overhead of the funtion calls alone vs directly access the data structure was twice as slow. I tested by actually creating the accessors without the use of AUTOLOAD. But that is the price to pay for OOP modularity, and generally well worth the performance price.