Question

So while attempting to patch a bug recently, a fellow hacker told me that since the value of the string passed to the subroutine (method) might be quite large, accessing it via $_[1] would avoid the memory copy. However, I thought that any value passed to a subroutine was copied to @_ in the first place? so in the below example is the memory copied twice? or am I wrong about the copy made when passing to the method?

sub foo {
    my $self = shift

    $_[0]    # access $str in @_ directly
    my ( $str ) = @_; # makes another copy of @_
}

sub bar {
    my $self = shift;
    my $str = 'something very large'; 

    $self->foo( $str ); #copies $str to the @_ of foo
}

This is why I suggested to the author allowing pass by a scalar ref, which will avoid a copy (other than the reference itself ) when passing to the method itself. To reiterate: does passing a value to a subroutine mean the value gets copied into @_?

Answer 1

According to http://perldoc.perl.org/perlsub.html (emphasis is mine):

Any arguments passed in show up in the array @_ . Therefore, if you called a function with two arguments, those would be stored in $_[0] and $_[1] . The array @_ is a local array, but its elements are aliases for the actual scalar parameters. In particular, if an element $_[0] is updated, the corresponding argument is updated (or an error occurs if it is not updatable). If an argument is an array or hash element which did not exist when the function was called, that element is created only when (and if) it is modified or a reference to it is taken. (Some earlier versions of Perl created the element whether or not the element was assigned to.) Assigning to the whole array @_ removes that aliasing, and does not update any arguments.

By my reading, this seems to indicate that, by default, no copy occurs into @_.

Though I will admit that the language used is a little obtuse.