「指针的指针」与「指针的引用」_tmp为指针的引用-CSDN博客

本文链接：https://blog.csdn.net/Izumi_Hanako/article/details/79011638

说在前面

Q：为什么me突发奇想要写一篇这个呢？
A：因为me的数据结构全是用指针写的，然而me经常被某个地方到底该不该传引用的问题困绕住…所以决定开一篇整理一发
Q：为什么要用指针写数据结构，麻烦死了…
A：
me觉得指针很清晰，符合正常思考方式，
比如root->leftson->val，就可以顺着读过去，表示的是root的leftson的val值
然而数组写法val[leftson[root]]，读过去大概是这样的：什么的val值呢？哦!原来是某个节点的leftson的val值。那么是哪个节点的leftson呢？哦!原来是root的leftson。看着都很烦啊= =…虽然也可以通过调换数组顺序使之读起来更人性化一些（val[leftson[root]]等价于root[leftson[val]]）

正文

下面只会讲是什么，而不会提到为什么（me的水平有限，也只是会用一点指针而已）
关于「为什么」的问题，可以去问问度娘。关于为什么有指针这个问题，可以去看看知乎这个问题下的回答传送门
更详细的介绍指针的资料：让你不再害怕指针

关于指针

虽然题目是「指针的指针」与「指针的引用」，还是简短的说一下指针吧=w=
指针变量存的是某个数据地址，通过访问地址就可以访问到所需的值。（直接访问变量，相当于知道它叫什么，指针访问变量，相当于知道它在什么位置，然后就去找到那个位置）

指针传参

指针传参和变量传参是一样的，都是相当于传了一个副本过去。在函数里修改指针参数时，外面的值并不会变，而修改指针所指向的值时，外面的值会变。
大概像下面这样：

#include <cstdio>

int A = 1 , B = 2 ;

void change( int *a , int *b ){
    a = b ;
}

void change_val( int *a , int *b ){
    *a = *b ;
}

int main(){
    printf( "A:%p , B:%p\n" , &A , &B ) ;
    int *p = &A ;
    change( p , &B ) ;
    printf( "p:%p (%d)  A = %d\n" , p , *p , A ) ;
    change_val( p , &B ) ;
    printf( "p:%p (%d)  A = %d\n" , p , *p , A ) ;
}

运行结果：这里写图片描述
第一行是A的地址和B的地址，接下来两行的格式都是：p所指的地址，地址里的值，以及A的值

指针的引用

其实也和普通的变量引用一样，这时候如果修改函数里的指针，外面的指针也会变。但是仅仅是指向的地方不一样了，原来指的变量还是不变
大概像下面这样：

#include <cstdio>

int A = 1 , B = 2 ;

void change( int *&a , int *b ){
    a = b ;
}

int main(){
    printf( "A : %p , B : %p\n" , &A , &B ) ;
    int *p = &A ;
    printf( "p:%p (%d)  A = %d\n" , p , *p , A ) ;
    change( p , &B ) ;
    printf( "p:%p (%d)  A = %d\n" , p , *p , A ) ;
}

运行结果：这里写图片描述
可以发现，p所指向的地方变了，但是原来指的变量没变

指针的指针

指针的指针相当于是记录下了「存地址的地方」在什么位置，这样的话就可以通过修改指针的指针的值，达到修改外部指针的目的。
大概像下面这样：

#include <cstdio>

int A = 1 , B = 2 ;

void change( int **a , int *b ){
    *a = b ;
}

int main(){
    int *p = &A ;
    int **pp = &p ;
    printf( "A : %p , B : %p\n" , &A , &B ) ;
    printf( "p : %p(%d) , pp : %p(%p)\n" , p , *p , pp , *pp ) ;
    change( pp , &B ) ;
    puts( "" ) ;
    printf( "A : %p , B : %p\n" , &A , &B ) ;
    printf( "p : %p(%d) , pp : %p(%p)\n" , p , *p , pp , *pp ) ;

}

运行结果：这里写图片描述
初始状态p存的是A的地址，*p的值是1，而pp存的是p的地址，*pp的值，也就是p的值，是A的地址。
在函数里将*pp修改成B的地址之后，外面也就不一样了

更多的指针的指针的指针，可以以此类推，大同小异

「指针的指针」与「指针的引用」

如果把指针的指针的值通过传引用，在函数里进行修改会怎么样呢

#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std ;

int A = 1 , B = 2 ;

void change( int *p ){
    printf( "\n&p: %p\n\n" , &p ) ;
    p = &B ;
}

void ext_change( int *&p ){
    printf( "\n&p: %p\n\n" , &p ) ;
    p = &B ;
}

int main(){
    int *tmp = &A , *pA = &A ;
    int **pp = &pA ;
    printf( "&A :%p , &B :%p\n\n" , &A , &B ) ;

    printf( "pA :%p( *pA : %d)\n" , pA , *pA ) ;
    printf( "tmp:%p( *tmp : %d )\n" , tmp , *tmp ) ;
    printf( "pp :%p -> *pp: %p( **pp : %d )\n" , pp , *pp , **pp ) ;

    //change( pA ) ;
    ext_change( *pp ) ;

    printf( "pA :%p( *pA : %d)\n" , pA , *pA ) ;
    printf( "tmp:%p( *tmp : %d )\n" , tmp , *tmp ) ;
    printf( "pp :%p , *pp: %p( **pp : %d )\n" , pp , *pp , **pp ) ;
}

运行结果：这里写图片描述
A的初值为1，B的初值为2。pA是一个指向A的指针，tmp是另一个指向A的指针，pp是指向pA的指针。
现在将*pp传引用进入函数（假设函数里的变量为p），可以发现，p的地址也就是pp里存的值，p和*pp都等于主函数里的pA。
那么显然的，给p赋上B的地址，也就会修改主函数里的pA，所以现在pA的值就是B的地址，**pp的值和*pA的值都是B的值，为2。

但是如果不传引用呢？可以试验一番，把change函数的注释删掉，然后注释掉ext_change函数。可以发现什么都没变，因为函数里的p是一个副本，p的地址并不是pp，因此给p赋上B的地址，然后什么也不会发生。

（当然如果在change函数里把*p赋上B的值，那么外面的A的值也就变成2了，这就是第一个试验里所提到的。）

于是大概有这样的收获：
某个变量的引用和该变量，它们的地址都是同一个，所以修改引用和修改变量，最后都修改了变量本身。而指针记录下了变量的位置，通过修改那个位置的值，达到了修改变量本身的目的。

循其本

me本来的目的大概是要搞平衡树来着…
比如替罪羊，它是需要重构的。记原来需要被重构的子树树根为A，A的父亲为fa，而重构之后的子树树根为B。

因为原来fa的某一个儿子是A，fa里存下了A的地址，但是现在重构了，fa现在的儿子应该是B，但是实际存的还是A没变。me想在重构的同时把fa里存的信息也给变了，又不想专门去维护father指针，于是就可以这样：

Node **Insert( Node *&nd , const int &x ){
    Node **rt = NULL ;
    int p = nd->cmp( x ) ;
    if( p == -1 )        nd->siz ++ , nd->cnt ++ ;
    else if( nd->ch[p] ) rt = Insert( nd->ch[p] , x ) ;
    else                 newNode( nd->ch[p] , x ) ;
    nd->updata() ;
    if( is_Bad( nd ) ) rt = &nd ;
    return rt ;
}

void rebuild( Node *&nd ){
//...
}

int main(){
//...
Node **tmp = Insert( root , x ) ;
if( tmp != NULL ) rebuild( *tmp ) ;
//...
}