[Resolved] Strange reference behavior

mflanagan

I have the following code:

<?php
$CmdObj = NULL;
...
Class x
{
}

function xmlCallback($attrib) {
   global $CmdObj;
...
   $CmdObj = new x();
   print_r($CmdObj);
}

// code that results in xmlCallback being called
...
print_r($CmdObj);

?>

As written above, this code works. Now, if I change the assignment to $CmdObj to this:

   $CmdObj = &new x();

$CmdObj is okay inside function xmlCallback, but is NULL in the 'main' part of the code.

I thought I could store a reference to an object just as easily as I store a copy of one. What am I missing?

Thanks.

ahundiak

This is a known bug in php4.
http://bugs.php.net/bug.php?id=22981
It's fixed in php5 but that does not you much good. As far as I can tell, you basically can't do what you want to do in php4. If the object HAS to be created using =& then you must create it outside of a function or wrap it in another class.

mflanagan

Thanks!

Just before I got your reply I rtfm (the help file, actually), and found, under the section titled 'Variable scope' a sub-head of which says:

References with global and static variables

The Zend Engine 1, driving PHP4, implements the static and global modifier for variables in terms of references. For example, a true global variable imported inside a function scope with the global statement actually creates a reference to the global variable. This can lead to unexpected behaviour which the following example addresses:

<?php
function test_global_ref() {
    global $obj;
    $obj = &new stdclass;
}

function test_global_noref() {
    global $obj;
    $obj = new stdclass;
}

test_global_ref();
var_dump($obj);
test_global_noref();
var_dump($obj);
?>

Executing this example will result in the following output:

NULL
object(stdClass)(0) {
}

So, does this mean that the help file is documenting this bug as expected behavior, or am I misinterpreting something (a very likely possibility!)?

ahundiak

I have spent some time researching and experimenting with references. My own conclusion is that no one really knows how they work. I just accept the fact that they do work consistently.

The bug report I gave has been closed with the notation "fixed in php 5". This is not really accurate. Using the & in php 5 still does not work as desired. Instead, under php 5 you don't need to use & any more to avoid getting a copy.

mflanagan

I'm with you on references. Here's what I'm finding out (assuming I understand references correctly):

A global inside a function is treated as a reference. So, if I say:

global $Cmd;
$Cmd = & new SomeClass();

there are two things of interest here. First is that the $Cmd inside the function is a reference 'pointing to' (in a symbol table sense) the real global $Cmd. I think it's best not to think of the $Cmd inside the function as the 'real' $Cmd, but rather as a local variable that is a reference to the real $Cmd. When I do the assignment, what I'm doing is setting the 'local' $Cmd to be a reference to the new object. The 'real' $Cmd isn't set to refer to that new object. It's as if I had something like this (ignoring for this example the fact that I would have to use a 'global' statement to get access to the global from within the function):

$Cmd = NULL;

function a()
{
   $localRef = &$Cmd;  // $localRef is a ref to the global $Cmd
   $localRef = 0;  // this would set $Cmd to 0
   $localRef =& new SomeClass();
   // note that after the line above, $localRef no longer refers to
   // $Cmd, but now refers to another object.
   // The last statement doesn't assign anything to $Cmd
   // (which $localRef was 'pointing to'). Rather, it redefines
   // $localRef to now be a reference to a new object.
}

That's why the 'real' $Cmd isn't changed.

Another way that might help to think about references is to realize that an 'assignment' of references isn't really doing an assignment. That is:

$ref = 0;  // a 'real' variable with a value of 0
$ref = & $someOtherVar;  // not a 'real' assignment

It helps for me to think of the second assignment as not an assignment at all. It does not assign a reference-to-$someOtherVar into $ref. Rather, it tells the symbol table manager that $ref is now a synonym for $someOtherVar. The data that used to be associated with $ref is thrown away.

Does this help, or have I made more of a hash of it?

In any case, here's what I had to do:

function Cmd()
{
    global $CmdObj;

parent::Element();
if (count($CmdObj) > 0)
    ReportParseError("More than one command found");

// We would like to say something simple, such as:
// $CmdObj = &$this;
// but that doesn't work.  $CmdObj is a global, so in this
// function it's really a reference.  We haven't really changed
// $CmdObj to 'point to' this object.
//
// Next on the simplicity scale would be something like:
// array_push($CmdObj, &$this);
//
// but array_push doesn't take a reference as a second arg.
//
// So, we push an array (containing a ref to ourselves) onto the
// $CmdObj array.
array_push($CmdObj, array(&$this));
}

I hope this helps.

swr

Good explanation, mflanagan. Extrapolating further, I think I have a solution.

Instead of using this:

global $foo;
$foo =& new Whatever();

Use this:
$GLOBALS['foo'] =& new Whatever();

Testing shows that this does, in fact, work.

From mflanagan's post and some guess work, I understand what is going on here.

When you say this:
global $foo;

It is equivalent to saying this:
$foo =& $GLOBALS['foo'];

So when you later do this:
$foo =& new Whatever();

It's changing $foo from being a reference to $GLOBALS['foo'] to being a reference to the new object. The actual $GLOBALS['foo'] variable is unaffected.

By using this:
$GLOBALS['foo'] =& new Whatever();
you cut out the $foo middle-man, and do what you actually meant.

ahundiak

swq,
Try your solution inside of a function. Sadly, I think you will find it does not work.

swr

Does work, ahundiak. Tested with the following code using PHP 4.3.3:

<html><body><pre>
<?php

$foo = null;

class Foo {
}

function func() {
    $GLOBALS['foo'] =& new Foo();
    print_r($GLOBALS['foo']);
}

func();
print_r($foo);
?>

However, if you were to change the func() function to look like this:

function func() {
   global $foo;
   $GLOBALS['foo'] =& new Foo();
   print_r($foo);
}

Then the print_r inside the function would not work, because it would be pointing to the old $GLOBALS['foo'], which is blank. But the actual $GLOBALS['foo'], and $foo in the global context, are now pointing to the object.

ahundiak

swr,
I sit corrected. Thanks.