Use of Reference Operator

[sguazt]

Hi,
I've just seen a new use, for me, of the reference

&

operator:

function foo( $s )
{
   $s .= 'bar';
}

$str = 'foo';
foo( & $str );
print( "$str\n" ); // output: 'foobar'

I've said to myself : "Great!!! I can use it for a large array", for example:

$idx = array_search( $el, & $bigArray );

or use when I need to save memory.

So I take a look inside the PHP doc but I didn't find that behaviour. So what about?
Is it a deprecated feature or is still valid and supported in php5?

Thanks a lot!!!!!

[laserlight]

$idx = array_search( $el, & $bigArray );

It doesnt make sense to pass $bigArray by reference, since array_search doesnt modify $bigArray.
You're probably thinking along the lines of C/C++, but PHP doesnt quite work the same way.

Read up the PHP manual on References Explained

[sguazt]

hmmm maybe I'm influenced by C/C++ langs but what if:

$a = array( $heavyObj1, ... $heavyObjN );
$r = array_search( $aHeavyObj, $a );

where

$heavyObjK

is an object of a user defined class taking a lot of memory.
Passing the array, does PHP pass a copy of it or simply pass the copy of, said in C term, the pointer to it?
If PHP pass a copy of the entire array I think that passing it's reference would allow me to save a lot of mem.

[laserlight]

In my opinion, it will not result in any memory savings.
array_search() would use the same memory location, until some alteration is made.

If array_search() altered the variable passed to it, then using & will result in memory savings, since array_search() would operate on the same memory location. Without &, it would then have to make a copy of the variable at the first point when alteration has to be made.

[sguazt]

By the way, I think if you have a function taking as parameter a big object you can trickly use the reference op to avoid data copying:

class Aggregate
{
  // ...
  function addElement( $item )
  {
     $this->_elements[] =& $item;
  }
}
//...

$el = new BigObject();
//...
$agg = new Aggregate();
$agg->addElement( $el ); // this causes $el to be copied on the stack
$agg->addElement( & $el ); // this causes the reference to $el to be copied on the stack

so the second call to addElement IMHO allow me to "save memory" that is to avoid useless copying.
I could use the pass-by-ref method to achieve the same result:

class Aggregate
{
  // ...
  function addElement( & $item )
  {
     $this->_elements[] =& $item;
  }
}
//...

$el = new BigObject();
//...
$agg = new Aggregate();
$agg->addElement( $el ); // this causes the reference to $el to be copied on the stack

However IMO is semantically wrong because it seems that function addElement is going to modify parameter $item.

What do u think about?

[poison]

not quite...it's a little more confusing if your coming from C++ ...

class Aggregate 
{ 
  // ... 
  function addElement( $item ) 
  { 
     $this->_elements[] =& $item; 
  } 
}

will be actually slower because you don't modify $item...since PHP works with reference counting and in this case wouldn't copy data if you used:

class Aggregate 
{ 
  // ... 
  function addElement( $item ) 
  { 
     $this->_elements[] = $item; 
  } 
}

I found a good article there ->http://www.zend.com/zend/art/ref-count.php

so the second call to addElement IMHO allow me to "save memory" that is to avoid useless copying.
I could use the pass-by-ref method to achieve the same result:

again, not absolutely right, you don't modify $item...
and another thing...be careful if you want to pass a reference to an instantiated object inside it's constructor...
$a=new A ();
actually instatiates an object and assigns a copy of that object...
at least in PHP4
regards