Now, when you pass by value, you are passing the actual variable's value when you called the function from the caller. This value is taken and a personal copy for that function and that function only is created. Any changes made to that copy do not affect any other variable in the system.

Now, to your issue. In C, some variables are actually smaller than passing a pointer (reference), so the passing by value was actually preferable over passing by reference! But in Perl, there are no data types- even strings are held in the same variable. A typical string (keeping it simple) will easily eat up more than 16 or 32 bits (a typical pointer size). While internally, the pass is made with a pointer, perl will create a dynamic memory copy at some point before it continues in your code. If you do not need another copy to work on, pass by reference. In C, there is no penalty for pointers (references). In Perl, the penalty can become substantial- especially if you are derefencing in a loop- especially in a main or very important loop! In all cases, you should

• consider whether you really need a function. Questions: Will i reuse this code again? Will I not be using it all too often (perhaps for a simple conversion only)? Do I need recursion?
• consider which variables that you need to pass. Questions: Is this variable relevant in the function context?
• choose pass ref or pass val. Questions: Will this variable remain constant throughout my function?(pass by val unnecessary) Do I need to take this variable and change it even in the encapsulating function? (reference required) Do I need my own copy of the variable for my own use without affecting other variables? (pass by val necessary unless you ref and then copy manually)

my $var=$bar->foo(); #deref here
&var;  #yet another deref?
[download]

AgentM Systems or Nasca Enterprises is not responsible for the comments made by AgentM- anywhere.

It's not entirely clear what you're trying to do in your question, but you're a little confused about the syntax.

To be able to call &var, there has to be an entry in the `var' stash's subroutine knob. In other words, you'd need to do this:

local *var = sub { ... }

So whatever you're doing above, if you're expecting $bar->foo() to return a subroutine reference, just stick it on the right side of my code there.

And yes, by doing this, you eliminate the dereferecing step. However, see tilly's response to this node where I mention this technique for reasons why this isn't generally all that useful.

-dlc

    $foo{'bob'};
[download]

    $bar->{'bob'};  # Slower, extra dereference
[download]

Also, remember using reference allows you to modify the actual variable, where normally you will just modify a copy.

I'm sure you understand what really happens in a sub, but your wording is a bit vague, so I'll clarify this for monks who might not be familiar with this issue.

You will only modify a copy of a variable passed to a sub if you copy the arguments to new variables. If you modify the @_ array directly, you modify the original variables. Run the following snippet to see what I mean:

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

my $test = "Hi there!";
change($test);
print $test;

sub change {
    $_[0] = "Hey, this is different!\n";
}
[download]

Cheers,
Ovid

Join the Perlmonks Setiathome Group or just go the the link and check out our stats.

Actually, it's not quit that simple. Perl's standard calling convention isn't pass by value. The values that you get in @_ are aliases to the original variables, so changing @_ will change the values outside the subroutine, as this simple test demonstrates.

my $x = 1;

mult($x);

print "$x\n";

sub mult {
  $_[0] *= 10;
}
[download]

--
<http://www.dave.org.uk>

"Perl makes the fun jobs fun
and the boring jobs bearable" - me

Bet on about 90-95% pass by reference but don't get into the habit without thinking about it. It can BITE you when you least expect it.

From the performance standpoint, really small lists don't matter =) On big lists, the answer is obvious.

--
$you = new YOU;
honk() if $you->love(perl)