PHP reference (&) variable reference, function reference, object reference, and parameter reference usage

PHP references (add & symbols before variables or functions, objects, etc.)

The reference in PHP means: Different names access the same variable content.
There is a difference between the pointers in the C language. In the C language, the pointer stores the address of the variable's contents in memory.

A reference to a variable

PHP references allow you to use two variables to point to the same content

<?
$a = "ABC";
$b =& $a;
echo $a;//output here: ABC
echo $b;//output here: ABC
$b = "EFG";
echo $a;//The value of $ A here becomes EFG so the output EFG
echo $b;//Output EFG here
Or

$a = "EFG";
echo $a;//The value of $ A here becomes EFG so the output EFG
echo $b;//Output EFG here

?>


Invocation of a function's address
Address call I'm not going to say much. Directly below the code

Function test (& $a)
{
$a = $a +100;
}
$b = 1;
echo $b;//Output 1
Test ($b); Here $b passed to the function is actually the memory address of the variable content of $b, by changing the value of $ A in the function can change the value of $b
echo "<br>";
echo $b;//Output 101

It is important to note that here Test (1), the words will be wrong, reason to think

A reference to the function returns
Look at the code first

function &test ()
{
Static $b =0;//declaration of a statically variable
$b = $b +1;
Echo $b;
return $b;
}

$a =test ();//This statement outputs a value of $b of 1
$a = 5;
$a =test ();//This statement outputs a value of $b of 2

$a =&test ();//This statement outputs a value of $b of 3
$a = 5;
$a =test ();//This statement outputs a value of $b of 6

The following explanation:
In this way $a=test (); The result is not a function reference return, which is not the same as a normal function call. The reason: It's php's rule.
PHP rules through $a=&test (); The way to get is the reference to the function is returned
As for what is a reference return (the PHP manual says that reference return is used when you want to use a function to find out which variable the reference should be bound to.) I haven't read this bullshit.

In the example above, the explanation is
$a =test () call the function, just assign the value of the function to $ A, and no change to $ A will affect the $b in the function.
by $a=&test (), the function is to call the memory address of the $b variable in the return $b to the same place as the memory address of the $ A variable.
That produces the equivalent effect ($a =&b;) So changing the value of $ A also changes the value of the $b so that it executes the
$a =&test ();
$a = 5;
Later, the value of the $b becomes 5

This is to let you understand that the function reference returns only use static variables, in fact, the function of the reference return is more used in the object

References to Objects

<?
Class a{
var $abc = "abc";
}
$b =new A;
$c = $b;
echo $b->abc;//here output ABC
echo $c->abc;//here output ABC
$b->abc= "DEF";
echo $c->abc;//here output def
?>

The above code is the result of running in PHP5
The replication of objects in PHP5 is done by reference. The above $b=new A; $c = $b; is actually equivalent to $b=new A; $c =& $b;
The default in PHP5 is to invoke the object by reference, but sometimes you might want to make a copy of the object, and you want the original object to change without affecting the copy. For this purpose, PHP defines a special method called __clone.

The role of references
If the program is larger, referencing the same object is more variable, and you want to use the object after the manual removal of it, the personal suggestion "&" method, and then $var=null to clear. At other times, it's the default way to use PHP5. In addition, in the PHP5 for large arrays of delivery, it is recommended to use "&" mode, after all, saving memory space to use.


Dereference
When you unset a reference, you just break the binding between the variable name and the variable content. This does not mean that the contents of the variable are destroyed. For example:

<?php
$a = 1;
$b =& $a;
unset ($a);
?>

Not unset $b, just $a.


Global references
When you declare a variable with the global $var, you actually establish a reference to the global variable. In other words, it is the same as doing this:

<?php
$var =& $GLOBALS ["var"];
?>

This means, for example, that the unset $var does not unset global variables.

$this
In the method of an object, $this is always a reference to the object that called it.


Here's a little episode.
PHP in the direction of the address (similar to the pointer) function is not implemented by the user itself, is implemented by the Zend Core, PHP refers to the use of "copy-on-write" principle, that is, unless a write operation, the same address to the variable or object is not copied.

The popular Speaking
1: If you have the following code

$a = "ABC";
$b = $a;

In fact, $ A and $b both point to the same memory address and not $ A and $b occupy different memory

2: If you add the following code based on the above code

$a = "EFG";

Since $ A and $b point to the memory of the data to be re-written once, at this time Zend core will automatically decide to automatically produce a $ A copy of the data for $b, re-request a piece of memory for storage

PHP reference (&) variable reference, function reference, object reference, and parameter reference usage