[RESOLVED] Another 'expected php behaviour' thing

Drakla

Ok - I've been using objects for 10 years now, but now and again something simple will make me go "Ehhhh?" in php. Anyone know why the repeats / no repeats happen in this:

class Basic {
	var $doNothing;

function Basic($from)
{
	echo "Basic::Basic saying you're creatin' from $from <br />";
}
}

// foo creates object with &new

function foo()
{
	static $v;

if (!$v)
	$v = &new Basic(__FUNCTION__);
}

// bar creates object with new (no &)

function bar()
{
	static $v;

if (!$v)
	$v = new Basic(__FUNCTION__);
}

foo();
foo();
foo();

bar();
bar();
bar();

/*	Outputs:
Basic::Basic saying you're creatin' from foo
Basic::Basic saying you're creatin' from foo
Basic::Basic saying you're creatin' from foo
Basic::Basic saying you're creatin' from bar 
*/

Cheers me dears.

Shrike

Check out the very end of this page before the user comments. It does seem like odd behaviour though.

A similar behaviour applies to the static statement. References are not stored statically

laserlight

$v in foo() is an alias for a Basic object.
At the end of foo(), this object goes out of scope, so $v goes out of scope - $v may be static, but what it is an alias of no longer exists, so it no longer exists and is reset on the next call to foo().

$v in bar() is a copy of a Basic object.
At the end of foo(), this object goes out of scope - but since $v is static, it retains the copy for the next call to bar().

This might demonstrate it more simply:

function baz() {
	static $a = 0;
	$b = 1;
	if ($a == 0) {
		$a = $b;
		echo "hi";
	} else {
		echo $a;
	}
}
baz();
baz();
baz();

We expect hi11 as the answer, since on the first call to baz(), $a is indeed 0, so the value of $b is copied to $a and "hi" is printed.
$a retains this value (i.e. 1) on the next call to baz(), so ($a == 0) is now false, hence the value of $a is printed.
Nothing really changes on the next call to baz(), so we get 11 as the output.

Let's change $a = $b; to $a =& $b;
On the first call to baz(), $a is 0, so $a is set as another name for $b (i.e. $a becomes an alias for $b).
But when baz() returns to the caller, $b goes out of scope.
So on the next call to baz(), $a is reset to 0, and we rinse, wash and repeat this for the next call to baz().
So we expect "hihihi" as the output, and in PHP 5.0.4 this is what I get.

Shrike

Does anyone know the purpose of creating an object by reference (e.g. =& new )? I've not been able to find the why, just the how.

laserlight

Shrike wrote:
Does anyone know the purpose of creating an object by reference (e.g. =& new )? I've not been able to find the why, just the how.

Read up on What References Do.

Shrike

Yes that explains the how but not the why. What is the benefit of

$class =& new stdclass;

over

$class = new stdclass;

I know the former creates a reference to the object itself rather than making a copy and assigning it, but what is the benefit of that (since the object itself cannot be referenced by any other variable). Of course we can say

$class =& new stdclass;
$class2 =& $class;

But how is that any different from

$class = new stdclass;
$class2 =& $class;

All I can see are performance reasons, but surely its not that significant.

laserlight

Yes that explains the how but not the why.

Did you read:
Note: Not using the & operator causes a copy of the object to be made. If you use $this in the class it will operate on the current instance of the class. The assignment without & will copy the instance (i.e. the object) and $this will operate on the copy, which is not always what is desired. Usually you want to have a single instance to work with, due to performance and memory consumption issues.

since the object itself cannot be referenced by any other variable

Of course it can.

Drakla

Thanks everyone. I was looking at that page last night, and how I didn't spot that I don't know.

The references with classes I do know, and there's a classic 'gotcha' example out there somewhere which I can't find, though might have been in user comments. I'll post it here without the solution that I wrote out to make it blatantly obvious to myself a year later what it was.

class A 
{ 
   function A($i) 
   { 
       $this->value = $i; 
       // try to figure out why we do not need a reference here 
       $this->b = new B($this); 
   } 

   function createRef() 
   { 
       $this->c = new B($this); 
   } 

   function echoValue() 
   { 
       echo "<br>","class ", get_class($this), '::', __FUNCTION__, '() - $this->value = ', $this->value; 
   } 
} 


class B 
{ 
   function B(&$a) 
   { 
       $this->a = &$a; 
   } 

   function echoValue() 
   { 
	   echo "<br>","class ", get_class($this), '::', __FUNCTION__, '() - $this->a->value = ', $this->a->value; 
   } 
} 

// try to undestand why using a simple copy here would yield 
// in an undesired result in the *-marked line 
$a = new A(10); 
$a->createRef(); 

$a->echoValue(); 
$a->b->echoValue();
$a->c->echoValue(); 

$a->value = 11; 

$a->echoValue(); 
$a->b->echoValue(); // * if $a = new A(10) and not $a = &new A(10) this would be 11
$a->c->echoValue(); 

/* 
output: with $a = &new A(10)
class A: 10 
class B: 10 
class B: 10 
class A: 11 
class B: 11 
class B: 11 

output: with $a = new A(10)
class A: 10 
class B: 10 
class B: 10 
class A: 11 
class B: 10
class B: 11 
*/

Shrike

laserlight wrote:
Did you read:
Note: Not using the & operator causes a copy of the object to be made. If you use $this in the class it will operate on the current instance of the class. The assignment without & will copy the instance (i.e. the object) and $this will operate on the copy, which is not always what is desired. Usually you want to have a single instance to work with, due to performance and memory consumption issues.

Of course it can.

I didn't really explain my meaning to well. Each call to new creates a new instance of an object. Of course the created object stored in the variable may be referenced, and this has obvious benefits. But on instanciation the difference seems minimal as to whether you make a reference or make a copy.

Edit: the last sentence in your quote mentions performance reasons and so I will take that as the reason 🙂

laserlight

$a =& new Foo;
$b = $a;
//$b is an alias of the Foo object that $a is an alias of

$c = new Foo;
$d =& $c;
//$d is an alias of $c
$e = $c;
//$e is a copy of $c

I suppose this can be seen as disabling the copy constructor (or subverting it to function as a pass by reference mechanism) of Foo for the instance of Foo instantiated by reference.

Drakla

Found the reference to that example, it's in the manual at http://uk.php.net/manual/en/language.oop.newref.php

Shrike, I think like the example shows, you're only going to get into weird behaviour when your class does referencing inside, so that the object assigned to your variable (e.g. $a = new Foo) isn't the same object assigned to something else called within the function with $thisRef = &$this;

I've completely blown the solution to that example, but whatever.

Shrike

I'm not following you now. Whether you make a reference or copy on instanciation has no bearing on further references.

Drakla

Ok, I just knocked this up as an explanation for myself. Foo sets a value to a reference to itself during creation

$lastObj = NULL;	// Foo should fill me up each create with a reference to the last object created
$lo = NULL;			// as above

class Foo
{
	var $name;

function foo($name = 'default')
{
	$this->name = $name;

	global $lastObj;			// this way won't work see http://uk2.php.net/static/ References with global and static variables
	$lastObj = &$this;

	$GLOBALS['lo'] = &$this;	// this way does
}
}

// call objects created by new X

$obj1 = &new Foo('Terry Jones');
$obj1->name = 'Stiffler';

echo '$lastObj->name = ' . $lastObj->name .'<br />';
echo '$lo->name = ' . $lo->name .'<br />';

// above $obj1 and $lo are the same object X

$obj2 = new Foo('Michael Palin');	// Oh, $obj2 is Y a copy of X
$obj2->name = 'Broomhilda';			// so here Y->name is changed

echo '$lastObj->name = ' . $lastObj->name .'<br />';
echo '$lo->name = ' . $lo->name .'<br />';				// still Michael Palin as $lo really is X

But you're right - on further references you will get the same object assigned to $obj1 or $obj2 but that won't be the same one assigned to $lo unless you've used &new

Shrike

Oh I see, you mean if a an object makes a reference to itself within itself (almost a circular reference) then there is a difference. However making the reference outside of the class produces the same (correct) result and maybe is a more appropriate way of doing things. Circular references for example cannot be stored in sessions. But I get your point.