Object Assignment in PHP

Setting $instance = null; doesn't update $assigned because it is not updating the data at the location where $instance points. It is instead modifying the $instance pointer itself so that pointer no longer points at the same data as $assigned.

An object is a separate entity in memory which can have 1 or more references. If it got 0, it is garbage collected.

A variable containing an object actually points to (refers to) that object. So when you do this:

$var1 = new Object();
$var2 = $var1;

you just create two variables, pointing to the same object ($var2 copies the value of $var1, but that value is the reference to the object).

If you then write, $var1 = null, you remove that one reference, but $var2 still points to the object.

The & operator actually returns a reference to the variable behind it, so when you write

$var1 = &var2;

then $var1 doesn't point to the object to which $var2 points as well, but $var1 points to $var2 itself. So when you make $var2 null, $var1 points to that same null.

With the following line, we reserve a memory location, in which storing the new Object, and a pointer to it, labeled as $instance:

$instance = new SimpleClass();

With the following line, we create a reference to the pointer $instance, labeled as $reference:

$reference =& $instance;

With the following line, we reserve a new memory location, labeled as $assigned, different and indipendent from the one above, in which we store a copy of the pointer (not the object itself) created above:

$assigned = $instance;

By setting $instance to null, you will unset only the pointer to the memory location which contains the actual object, not the object itself. Any other reference to it (for instance, $reference) will be unset as well.

$assigned is an indipendent copy of the pointer (held in another memory location), which still points to the actual object.

This is why it can be still used to refer to the actual object.

This comment found in the PHP documentation comes in support of what above said:

<?php
class A {
    public $foo = 1;
}  

$a = new A;
$b = $a;
$a->foo = 2;
$a = NULL;
echo $b->foo."\n"; // 2

$c = new A;
$d = &$c;
$c->foo = 2;
$c = NULL;
echo $d->foo."\n"; // Notice:  Trying to get property of non-object...
?>

Note

This represents a kind of exception when speaking about memory management. Whereas copying a variable or array is addressed just by to use the = operator, with objects you shall explicitely use the clone keyword, as stated in the PHP documentation:

An exception to the usual assignment by value behaviour within PHP occurs with objects, which are assigned by reference in PHP 5. Objects may be explicitly copied via the clone keyword.

Short answer, when you create a reference using &, this is what happens:

$A  ===+
       |===> [symbol table entry x] ====> (memory location)
$B  ===+

When you do a normal assignment after that:

$A  ===+
       |===> [symbol table entry x] ===> (memory location)
$B  ===+                                    ^
                                            |
$C  =======> [symbol table entry y] ========+

Let's step through the code:

$instance = new SimpleClass();

$assigned   =  $instance;

Assertion:

$assigned === $instance

Both $assigned and $instance reference the same instance of SimpleClass.

$reference  =& $instance;

Assertion:

$assigned === $instance === $reference

All variables reference the same instance.

$instance->var = '$assigned will have this value';

Assertion:

$assigned === $instance === $reference

Even though a property of $instance is changed, it doesn't affect the references.

$instance = null; // $instance and $reference become null

Because $reference is just an alias in the symbol table, it gets the same value as $instance; the reference count of the the original instance (i.e. memory location) gets reduced to 1, the $assigned variable.

As you can see in the code

$instance = null; // $instance and $reference become null

$instance has now become equal to null, but before then $assigned was set. so $assigned did not get the null value. $reference received the null value because you referenced it with =& it keeps the value of $instance.

It's really simple:

$a = 3;
$b = $a;
$c = &$a;
$a = 0;

var_dump($a);
var_dump($b);
var_dump($c);

The output will be:

int(0)
int(3)
int(0)

So it not only object assignment but also normal assignment.