php学习 --9 引用

引用：

$a = &$b;//a，b指向同一个变量,可以通过unset来断开指向
$a = 7;//a为7，b变7

//以下，未定义的变量进行引用赋值，引用参数传递或者引用返回，会自动创建该变量
function foo(&$v){}
foo($a);
$b = array();
foo($b['b']);
$c = new S();
foo($c->d);

在函数中引用全局变量
$var1 = "Example variable";
$var2 = "";
function global_references($use_globals)
{
    global $var1, $var2;// 函数内的var1，var2指向全局变量
    if (!$use_globals) {
        $var2 =& $var1; // 函数内的var2指向了var1指向的内容，全局变量没有更改
    } else {
        $GLOBALS["var2"] =& $var1; // var2全局变量更改，指向函数内var1指向的全局变量
    }
}

global_references(false);
echo "var2 is set to '$var2'\n"; // var2 is set to ''
global_references(true);
echo "var2 is set to '$var2'\n"; // var2 is set to 'Example variable'

在foreach中使用引用变量赋值
$r = 0;
$v = &$r;
foreach(array(1,2,3) as $v){
    ...//each time assign element in array to $v pointing value
}
//$r = 3;  

通过＝的数组拷贝
只是简单的拷贝，并非引用（对象的复制是引用）。如果数组中包含引用（引用或者其他变量对其元素的引用），则数组自身通过值来传递，而其中的引用仍是原来的引用。
<?php
$a = 1;
$b = array(1,2,&$a);
$e = &$b[1];
$c = $b;
$c[0]=0;
$c[1]=0;
$c[2] = 0;
echo $c[2];
echo "\n";
print_r($b);
echo $a;
?>
output:
0
Array
(
    [0] => 1
    [1] => 0
    [2] => 0
)
0

引用不是指针

function foo(&$v){
    $v = &$GLOBALS['b'];
}
foo($bar);
//不能达到预期的效果
$v = &$bar;
//bar\
//   bar_value
// v/
 $v = &$GLOBALS['b'];
 //v \
 //   GLOBALS['b']'s value
 //b /
 //bar-->bar_value

函数中参数的引用

<?php
$b =0;
$c =1;
function s(&$v){
    global $c;
    $v = &$c;// 改变的函数内v的指向
}
function t(&$v){
    global $c;
    $v = $c;// 改变指向的内容
}
function l(&$v){
    $v = 7;// 改变指向的内容
}
s($b);//0
t($b);//1
l($b);//7
?>
 注意：
 通过引用传递的只能是：变量，例如foo($a)
                   new语句，例如foo(new foobar())
                   从函数中返回的引用，例如：
                   <?php
                    function &bar()
                    {
                     $a = 5;
                     return $a;
                    }
                    foo(bar());
                    ?>

引用返回

class foo{
    public $v =42;
    public function &getValue(){//返回的引用
        return $this->v;
    }
}
$o = new foo;
$m = &$o->getValue();//引用的绑定
$o->v = 2;// $m =2;
注意：
如果试图通过return ($this->v) 这种形式来返回，会不起作用并报错。
因为这是试图返回一个表达式的结果而不是一个引用的变量。

取消引用
通过unset一个引用来进行取消。

$a = 2;
$b = &$a;
//a \
//   2
//b /
unset($b);
//a -- 2
//b

一些有用的东西（自手册）

pointer |value|variable
1       |NULL |
2       |NULL |
3       |NULL |
4       |NULL |
5       |NULL |

$a = 10;
$b = 20;
$c = array('one'=>array(1,2,3));
pointer |value|variable
1       |10   |a
2       |20   |b
3       |1    |c['one'][0]
4       |2    |c['one'][1]
5       |3    |c['one'][2]

$a = &$c['one'][2];
pointer |value|variable
1       |NULL |
2       |20   |b
3       |1    |c['one'][0]
4       |2    |c['one'][1]
5       |3    |c['one'][2],a

$b = &$a;
pointer |value|variable
1       |NULL |
2       |NULL |
3       |1    |c['one'][0]
4       |2    |c['one'][1]
5       |3    |c['one'][2],a,b

unset($c['one'][2]);
pointer |value|variable
1       |NULL |
2       |NULL |
3       |1    |c['one'][0]
4       |2    |c['one'][1]
5       |3    |a,b

$c['one'][2] = 500;
pointer |value|variable
1       |500  |c['one'][2]
2       |NULL |
3       |1    |c['one'][0]
4       |2    |c['one'][1]
5       |3    |a,b

$c['one'][2] = &$a;
unset($a);
unset($b);
pointer |value|variable
1       |NULL |
2       |NULL |
3       |1    |c['one'][0]
4       |2    |c['one'][1]
5       |3    |c['one'][2]


$a = "hihaha";
$b = &$a;
$c = "eita";
$b = $c;
echo $a; // shows "eita"

$a = "hihaha";
$b = &$a;
$c = "eita";
$b = &$c;
echo $a; // shows "hihaha"

$a = "hihaha";
$b = &$a;
$b = null;
echo $a; // shows nothing (both are set to null)

$a = "hihaha";
$b = &$a;
unset($b);
echo $a; // shows "hihaha"

$a = "hihaha";
$b = &$a;
$c = "eita";
$a = $c;
echo $b; // shows "eita"

$a = "hihaha";
$b = &$a;
$c = "eita";
$a = &$c;
echo $b; // shows "hihaha"

$a = "hihaha";
$b = &$a;
$a = null;
echo $b; // shows nothing (both are set to null)

$a = "hihaha";
$b = &$a;
unset($a);
echo $b; // shows "hihaha"

引用定位

global引用
global $var 声明一个变量实际上建立了一个到全局变量的引用。等同于：$var = &$GLOBALS["var"]

$this
在一个对象方法中，$this永远是调用它的对象的引用。