I believe the following discussion from Web Application Development with PHP 
4.0 (available online at http://safari.oreilly.com) may shed some light on 
your question...


Whenever PHP encounters a statement for which write access to a variable is 
needed, it evaluates and calculates the data that will be written into the 
variable, copies it, and assigns the result to the target space in memory. 
(This description is a little bit simplified, but you get the idea.)

$some_var = 2;

$my_var = $some_var * 3;

$new_var = $some_var + $my_var;

Looking at this script, PHP will

Create space for $some_var and write 2 into it.

Create space for $my_var, retrieve the value of $some_var, multiply it by 3, 
and assign it to the newly allocated memory.

Create space for $new_var, retrieve the values of $some_var and $my_var, 
total them, and write them back to the new place in memory.

Well, this sounds nice and logical—but these are simple types and you've 
worked with them many times already. Things are very different (and 
illogical) when PHP is handling classes:

class my_class
   var $var1, $var2, $var3;

$my_object = new my_class;

$my_object->var1 = 1;
$my_object->var2 = 2;
$my_object->var3 = 3;

$new_object = $my_object;

$new_object->var1 = 3;
$new_object->var2 = 2;
$new_object->var3 = 1;

print("My object goes $my_object->var1, $my_object->var2, $my_object->var3 
print("New object goes $new_object->var1, $new_object->var2, 
$new_object->var3 !<br>");

What do you think this will produce as output? The script first declares a 
class, creates one instance of it, and assigns values to its three 
properties. After having done this, it creates a new reference to this 
object, reassigns its properties, and then just prints out each property by 
using both references. Remember, one instance. Figure 2.7 shows the result.

Figure 2.7. PHP creating a copy instead of a reference.

If you're not surprised now, you either know PHP very well already or 
haven't thought enough about objects yet. PHP has created a copy, a new 
instance of my_class instead of just a new reference! This is not the 
desired behavior, since the new operator is supposed to create an instance 
of my_class in memory, returning a reference to it. Thus, when assigning 
this reference to another variable, only the reference should be copied, 
leaving the original data untouched—similar to a file system link, which 
allows access to the same data through different locations on the file 
system. This behavior of PHP—creating copies of referenced data rather than 
just the reference itself—may not sound important enough to focus on; 
however, you'll see in a moment that it actually does make a difference.

Note:   At the time of this writing, both PHP 3.0 and PHP 4.0 are using copy 
syntax. A chat with someone closely involved in the core development 
revealed that the plan is to change the default behavior to use a reference 
syntax, but this change would cause a loss of backward compatibility. A 
possible change is planned with version 4.1—if this happens, information 
contained here will be invalid for all future versions.

Web Application Development with PHP 4.0

Tobias Ratschiller
Till Gerken
Zeev Suraski
Andi Gutmans
Publisher: New Riders Publishing
First Edition July 12, 2000
ISBN: 0-7357-0997-1, 416 pages

Send and receive Hotmail on your mobile device: http://mobile.msn.com

PHP General Mailing List (http://www.php.net/)
To unsubscribe, visit: http://www.php.net/unsub.php

Reply via email to