Describe this syntax

[PyroX]

Why would one write a function like this?

function & testdata(){
return $value;
}

What is the signifigance of the '&' ?

[orangehairedboy]

Never seen a & before the function name. You can use the & before a variable ( &$myvar ) to use a reference to the original variable.

Example:

$answer=0
Deep_Thought( $answer );
print "The Answer to Life, the Universe, and Everything is...$answer"; /* Prints 42 */

function Deep_Thought ( &$answer )
 {
 $answer = 42;
 }

[PyroX]

It occurs in several classes I have been looking at just now.

EXAMPLE:

<?php
/**
 *  Base class for data access objects
 */
class Dao {
    /**
    * Private
    * $da stores data access object
    */
    var $da;

//! A constructor
/**
* Constructs the Dao
* @param $da instance of the DataAccess class
*/
function Dao ( & $da ) {
    $this->da=$da;
}

//! An accessor
/**
* For SELECT queries
* @param $sql the query string
* @return mixed either false if error or object DataAccessResult
*/
function & retrieve ($sql) {
    $result=& $this->da->fetch($sql);
    if ($error=$result->isError()) {
        trigger_error($error);
        return false;
    } else {
        return $result;
    }
}

//! An accessor
/**
* For INSERT, UPDATE and DELETE queries
* @param $sql the query string
* @return boolean true if success
*/
function update ($sql) {
    $result=$this->da->fetch($sql);
    if ($error=$result->isError()) {
        trigger_error($error);
        return false;
    } else {
        return true;
    }
}
}
?>

[orangehairedboy]

Well, this claims to explain it...but at first read it's doesn't seem like English!

http://www.php.net/manual/en/language.references.return.php

Hope that helps anyway! Maybe you can translate if you ever figure out what the hell it means 😃

OHB

[Weedpacket]

Um, does this help at all?

[orangehairedboy]

Originally posted by Weedpacket
Well the definitive, if terse, guide to returning references to variables is of course the manual.

Here's a more elaborate example, though, in which I make $e a reference to a variable with a nondeterministic value inside the function testme:

function &testme()
{	static $a = 0;
	$a = microtime();
	return $a;
}

$e =& testme();
var_dump($e);
$b =& testme();
var_dump($e);

If $a wasn't made static, its value would be destroyed when the function ended. $e would then become the only variable referencing the value in question, and it wouldn't be updated when testme() was run for the second time (try it!) - the $a in the second run of the function woudl be an entirely separate beast from the $a in the first run.

That's if the static keyword isn't used. Since it is, it is preserved from one run to the next, and $a and $e both reference the same value.

It's actually a peek into how PHP stores variables and values. In a sense all variables are references. PHP keeps a big table of all the variables currently defined, and next to each variable name is a (C-like) pointer into a location in memory where the value is stored. When you say that one variable is a reference of another, what you're saying is that both variables are pointing to the same location in memory; a straight reassignment sees the two variables involved pointing to different memory locations that contain the same value.[*]

It'd help (it helped me) to draw a few diagrams at this point...

Saying that "$a is a reference to $b" (or, equivalently, "$b is a reference to $a") is therefore misleading! Neither is referring to the other; instead they're both referring to the same location in memory.

*That's a good enough description for a first approximation. Needless to say, there are all sorts of opportunities for elaboration and optimisation, and PHP makes many of them (e.g., the symbol table contains typing information); but they're all behind-the-scenes and don't have any visible effect on the above. [/B]

So, basically, $e is not a copy of the returned value (which is retained in $a in the function), it is a reference to the value. When $a is changed, so is $e.

Thanks! I guess you do learn something new every day...

[128kb_com]

But is the =& in $e =& testme(); required?

Because wouldn't $e === the same thing when using the =& as it would if function &testme() {} was declared without the &, like - function testme() {} ???

[orangehairedboy]

Technically, in this example, no. However, the point is that $e is not a copy of $a...it is a reference to $a.

If you add a line:

$f =& testme();

then $f = $e.

[Weedpacket]

Originally posted by orangehairedboy
Technically, in this example, no. However, the point is that $e is not a copy of $a...it is a reference to $a.

If you add a line:

$f =& testme();

then $f = $e.

Exactly.

function &testme() means that a reference is returned from testme() - somewhere in memory there is a location where the function's return value is stored, and the reference points to that.

But if you say $f = testme(), $f still ends up pointing to a copy of the return value, not the original.

Counterintuitive, I know - I certainly found it that way at first (and I still hardly ever use it!). But the idea (and reason for doing it) is basically to make sure that everyone using that particular resource or object really is using the same resource or object, and not copies.