Why does PHP's call_user_func() function not support passing by reference?

Question

Why don't the function handling functions like call_user_func() support passing parameters by reference?

The docs say terse things like "Note that the parameters for call_user_func() are not passed by reference." I assume the PHP devs had some kind of reason for disabling that capability in this case.

Were they facing a technical limitation? Was it a language design choice? How did this come about?

EDIT:

In order to clarify this, here is an example.

<?php

function more(&$var){ $var++; }

$count = 0;
print "The count is $count.\n";

more($count);
print "The count is $count.\n";

call_user_func('more', $count);
print "The count is $count.\n";

// Output:
// The count is 0.
// The count is 1.
// The count is 1.

This is functioning normally; call_user_func does not pass $count by reference, even though more() declared it as a referenced variable. The call_user_func documentation clearly says that this is the way it's supposed to work.

I am well aware that I can get the effect I need by using call_user_func_array('more', array(&$count)).

The question is: why was call_user_func designed to work this way? The passing by reference documentation says that "Function definitions alone are enough to correctly pass the argument by reference." The behavior of call_user_func is an exception to that. Why?

Answer 1

The answer is embedded deep down in the way references work in PHP's model - not necessarily the implementation, because that can vary a lot, particularly in the 5.x versions. I'm sure you've heard the lines, they're not like C pointers, or C++ references, etc etc... Basically when a variable is assigned or bound, it can happen in two ways - either by value (in which case the new variable is bound to a new 'box' containing a copy of the old value), or by reference (in which case the new variable is bound to the same value box as the old value). This is true whether we're talking about variables, or function arguments, or cells in arrays.

Things start to get a bit hairy when you start passing references into functions - obviously the intent is to be able to modify the original variables. Quite some time ago, call-time pass-by-reference (the ability to pass a reference into a function that wasn't expecting one) got deprecated, because a function that wasn't aware it was dealing with a reference might 'accidentally' modify the input. Taking it to another level, if that function calls a second function, that itself wasn't expecting a reference... then everything ends up getting disconnected. It might work, but it's not guaranteed, and may break in some PHP version.

This is where call_user_func() comes in. Suppose you pass a reference into it (and get the associated the call-time pass-by-reference warning). Then your reference gets bound to a new variable - the parameters of call_user_func() itself. Then when your target function is called, its parameters are not bound where you expect. They're not bound to the original parameters at all. They're bound to the local variables that are in the call_user_func() declaration. call_user_func_array() requires caution too. Putting a reference in an array cell could be trouble - since PHP passes that array with "copy-on-write" semantics, you can't be sure if the array won't get modified underneath you, and the copy won't get detached from the original reference.

The most insightful explanation I've seen (which helped me get my head around references) was in a comment on the PHP 'passing by reference' manual:

http://ca.php.net/manual/en/language.references.pass.php#99549

Basically the logic goes like this. How would you write your own version of call_user_func() ? - and then explain how that breaks with references, and how it fails when you avoid call-time pass-by-reference. In other words, the right way to call functions (specify the value, and let PHP decide from the function declaration whether to pass value or reference) isn't going to work when you use call_user_func() - you're calling two functions deep, the first by value, and the second by reference to the values in the first.

Get your head around this, and you'll have a much deeper understanding of PHP references (and a much greater motivation to steer clear if you can).

Answer 2

See this:

http://hakre.wordpress.com/2011/03/09/call_user_func_array-php-5-3-and-passing-by-reference/

Is it possible to pass parameters by reference using call_user_func_array()?

http://bugs.php.net/bug.php?id=17309&edit=1

Passing references in an array works correctly.

Answer 3

Updated Answer:

You can use:

call_user_func('more', &$count)

to achieve the same effect as:

call_user_func_array('more', array(&$count))

For this reason I believe (unfoundedly) that call_user_func is just a compiler time short cut. (i.e. it gets replaced with the later at compile time)

To give my view on you actual question "Why was call_user_func designed to work this way?":

It probably falls under the same lines as "Why is some methods strstr and other str_replace?, why is array functions haystack, needle and string functions needle, haystack?

Its because PHP was designed, by many different people, over a long period of time, and with no strict standards in place at the time.

Original Answer:

You must make sure you set the variable inside the array to a reference as well.

Try this and take note of the array(&$t) part:

function test(&$t) {
    $t++;
    echo '$t is '.$t.' inside function'.PHP_EOL;
}

$t = 0;
echo '$t is '.$t.' in global scope'.PHP_EOL;

test($t);

$t++;
echo '$t is '.$t.' in global scope'.PHP_EOL;

call_user_func_array('test', array(&$t));

$t++;
echo '$t is '.$t.' in global scope'.PHP_EOL;

Should output:

$t is 0 in global scope
$t is 1 inside function
$t is 2 in global scope
$t is 3 inside function
$t is 4 in global scope

Answer 4

Another possible way - the by-reference syntax stays the 'right' way:

$data = 'some data';
$func = 'more';
$func($more);

function more(&$data) {
  // Do something with $data here...
}