指针与二级指针

为了把引用 解引用 取地址 指针 双指针 指针的引用 二级指针 这一块弄清楚，钻研与查阅资料得到如下体会；

1.        引用与取地址  (reference and address)  引用的&前面一定有类型符号，否则就不是引用， 取地址的&后面一定有变量名称，一旦出现&，一定把此搞明白

 int b =10, int &a,  这明显就是引用，&b 这就是取地址， test1(int &a, int &b) 这些是引用用在定义函数的时候， test4(&a, &b) 这个时候是取地址，&后面必须是变量名字，不能是其它的，比如&*b是不容许的，

2.       引用是变量的别名，与变量有相同的地址和值， & 只在定义的时候出现，以后不用出现， int &a =b,   以后直接在使用的时候用a 代表b, 不是用&a 代表b （单独出现&a，此时就是应用的地址了， 它就是b的地址)  &a==&b，地址是相等的。函数中如传递变量，  f(b), 如需要传递变量的地址f(&b)

3.     一个变量（包括指针）包括三个部分， 变量名字， 变量的值， 变量的地址，内存中地址是唯一的， 生命周期内名字和地址是关联的，多个名字可关联一个地址，值是地址上的储存内容，可以变的，名字没有直接和值关联，名字关联地址，地址在关联值， 这三个是三回事，地址和引用，地址，解引用就是解决此三部分不同的问题。

     一般的赋值等是对变量的值赋值，而不是地址等其他的， int b=10, 是b的值赋为10， 而不是地址 int *f ， f=&b, 这是把指针的值赋为b的地址，而指针f本省的地址没有涉及

4.     指针与解引用 （pointer and dereference)  指针的*前面一定有类型符号，否则就不是指针， 解引用的*后面一定要有地址（指针或相当于值是地址的变量）一旦出现×,一定高明，  int * f, 只是指针定义， 而如果单独出现 *f 这个时候是解引用，  test8(int ×a, int ×b) 这些是指针用在定义函数的时候， test9(×a, ×b) 这个时候是解引用，传递的指针对应的解引用， ×&f  这个就是变量f的地址的解引用，就是变量f的值

5 . 指针里面的值是变量的地址， × 只在定义的时候出现，以后不出现， int*f,   f=&b,  以后直接用f 代表 &b, 用*f(解引用)代表b, 代表是可以写等于的意思。而不是以后也用*f=&b， f=b.

6. 指针就是变量本身储存的值是另一个变量的地址， 和它本身的地址是两回事， 解引用是指针的值(地址）作为另一个变量的地址， 这个地址对应的值。int *f =&b, 

此时f的地址是：HHH, f的值是AAA,  b的地址是AAA, b的值是CCC,  HHH 就是&f, ×f 就是CCC。二级指针就是指向指针的指针，相当于这里的CCC又是一个变量的地址， 

7. 作为参数传递等的时候，一定要抛开类新定义时前两*或&的符号，左边的值与右边建立对等关系 ，左边值是地址，右边就是地址，左边值是值， 右边也就是普通的值，  如 fee(int* f)， int k,  在实参引用的时候要fee(&h), 不能fee(h), 因为定义中*是类型符号，f的值是地址， 要与&h才一直，  fee(int &h) , int k,  在实参引用的时候要fee(k). 因为&是类型符，h是引用，值和变量一样， 而不能是地址参数fee(&h)

8.  引用不分配内存， 而指针分配， int d, int& f=d,, int *u =&d , 此时d和f 的值， 地址一模一样，u的值和d的地址上一样， u有它自己的地址。

9. 作为参数传递，指针作为参数的时候是临时拷贝一个副本( 不同的地址），它的值和原来的指针一样，及指向的地址和原来的指针指向的一样，他们有相同的解引用，因此对函数内这个临时指针的值的操作都不会影响到原来的指针，只是把临时指针的值变了，及指的地址变了，如果不对这个临时指针操作，而对它的解引用操作， 由于和原来的指针指向同一个地址，有相同的解引用，因此对临时指针的解引用操作会影响到原来的解引用，要在函数退出后而使原来的值的变化有保留，就必须把要改变的值放在传递指针的解引用里面。 要想让指针作为参数在函数中操作完后有变化有保留，因此要让产生的临时指针指向这个指针的地址，临时指针的解引用就是这个指针，临时指针的解引用变化，这个指针的值就变化，这个指针的解引用，和临时指针的解引用的解引用一致，就是二级指针或双指针。及指针用作参数传出时需要二级指针。

int *a=&b, 

int c*=&d,   

exchange(int*f, int*e),  

{

  int * temp 

temp =f;

f=e,

e=temp

}

exchange(a, c)

执行时； 

f 是一个临时指针指向b的地址， *f就是b    函数外a 指向b的地址

e是一个临时指针指向d的地址， *e就是d   函数外c指向d的地址

交换后

f 是一个临时指针指向d的地址， *f就是d    函数外a 指向b的地址

e是一个临时指针指向b的地址， *e就是b   函数外c指向d的地址

因此函数内部变了，外部没有变， 退出后还是原样子。

如果是

exchange(int*f, int*e),  

{

  int  temp 

temp =*f;

*f=*e,

*e=temp

}

exchange(a, c)

此时执行

f 是一个临时指针指向b的地址， *f就是b    函数外a 指向b的地址 *a就是b

e是一个临时指针指向d的地址， *e就是d   函数外c指向d的地址  *c就是d

交换后

f 是一个临时指针指向b的地址， *f就是d    函数外a 指向b的地址 *a就是b   但此时 b的值变成d的值了，  b的名称和地址没有变

e是一个临时指针指向d的地址， *e就是b   函数外c指向d的地址  *c就是d   但此时 d的值变成b的值了      d的名称和地址没有变

如前名称和地址是绑定的， 这次是把值变了

如果是

exchange(int**f, int**e),  

{

  int * temp 

temp =*f;

*f=*e,

*e=temp

}

exchange(&a, &c)  注意此时格式

执行时 

f 是一个临时指针指向指针a的地址， *f就是a,    * a就是b, **f就是 b,   函数外a 指向b的地址 *a就是b

e是一个临时指针指向指针c的地址， *e就是c    *c就是d, **e就是 d     函数外c指向d的地址  *c就是d

执行后

f 是一个临时指针指向指针a的地址， *f就是a, 此时a的名称和地址没有变，但值变成了c的值   * a就指向* c 即 d, **f就是 d,   函数外a 指向d的地址 *a就是d

e是一个临时指针指向指针c的地址， *e就是c  此时c的名称和地址没有变， 但值变成a的值，  *c就指向*a  即 b, **e就是 b     函数外c指向d的地址  *c就是b

这样的操作是在指针的值的层面上做了交换，上面一种是在原数据基础上做了交换。 

10. 引用作为参数，是直接把实参的地址和值当作引用的，起了个别名，相当于给这段地址关联了一个名字，相比指针少了一个临时的指针的地址。因此函数内部对别名的操作就相当于对原实参操作。

exchange(int &f, int &e),  

{

  int  temp 

temp =f;

f=e,

e=temp

}

exchange(b, d)

执行时
f 的值是b, f的地址是b 的地址

e的值是d, e的地址是 d 的地址

执行后

 f的值是c的值， f 的地址还是原来b的地址 b的地址中变成c的值了

e的值变为d的值， e的地址还是原来b的地址， c的地址中变成b的值了，

在数值层面上交换了。

11. 引用和指针相结合，产生了指针类型的引用 int *&f  它的意思是f和一个指针有相同的地址和值。

exchange(int *&f, int *&e),  

{

  int  temp 

temp =f;

f=e,

e=temp

}

exchange(a, c)  注意里面一定要指针

执行时   f  就相当于指针  a

e 就相当于指针c, 

 这样相当于把外面指针直接拿到函数内使用了。 比刚才二级指针效率提升了许多。

引申 

一般的情况是

            二级指针——> 一级指针—->原数据

 要想原数据改变有多种方式

           直接改变 

           利用一级指针做中介 改变一级指针的解引用

           利用二级指针做中介，改变二级指针的解引用， 此时绑定一级指针值和原数据，

           使用指针作为中介的地方都可直接使用引用。去掉中介。

————-