Análisis en profundidad del puntero de pila.

¿Por qué el valor de imprimir raíz es el mismo que el valor de & raíz->valor?

 Resultados de la prueba:

¿Qué es exactamente la variable *?

Escribí una oración antes, es decir, si ves una variable *, es la dirección de memoria almacenada en esta variable, y luego saca el valor o dirección correspondiente almacenado en ella.

Entonces, ¿cómo entender esta oración? Se puede decir así.

Entonces los resultados impresos arriba son los mismos y se eliminan las direcciones de &num1

La descripción del código específico es la siguiente:

#include <cstdio>
#include <cstdlib>

using namespace std;

int main()
{
    int num1 = 3;
    int *p_num1 = &num1;
    int **pp_num1 = &p_num1;
    int ***ppp_num1 = &pp_num1;

    printf("%d\n",*p_num1);//直逼num1，所以打出来是3

    printf("%d  %d\n",*pp_num1,&num1);//直逼p_num1，取出来就是num1的地址

    printf("%d  %d\n",*ppp_num1,&p_num1);//直逼pp_num1,取出来p_num1的地址

    //第一个*号直逼pp_num1,取出&p_num1地址
    //第二个*号直逼p_num1，取出&num1的地址
    printf("%d  %d\n",**ppp_num1,&num1);
    
    //这里有两个**,一个*直逼pp_num1保存的地址就是p_num1，取出来是
    //&num1的地址，然后再来一个*,直逼num1的地址，取出来的就是3
    printf("%d\n",**pp_num1);

    return 0;
}

resultado de la operación:

,&(*root)->left ¿Por qué la expresión informa un error?

Antes de hablar de esto, analicemos los valores de las siguientes expresiones.

Ejemplo 1: printf("%d %d %d %d\n",&(*root),root,&root->valor,&root);

 Expresión 2: printf("%d %d\n",&(*pp_root)->izquierda,&root->izquierda);

Ejemplo 3: printf("%d %d %d\n",(*pp_root)->left,root->left,&child->value);

Déjame hablar sobre por qué &(*root)->left informó un error

primero mira una foto

Analicemos lo anterior: Primero, *root devuelve un objeto de nodo sin una referencia de puntero, por lo que el compilador ->left informará un error.

Dado que se devuelve el objeto de nodo en sí, se puede hacer referencia a él con ., ya que las dos expresiones siguientes tienen el mismo valor

 Por eso reporta un error

Análisis de nodos de memoria de árbol binario

 

Cuando su número * está cerca de una dirección asignada en el montón, lo que se devuelve 

 

Entonces, ¿qué devuelve este *p_root? Como dije antes, si el número * es una variable, entonces es directamente igual al valor de la dirección de memoria guardada por esta variable, ya sea una dirección o un valor.

Aquí *p_root es obviamente la situación señalada por la flecha azul a continuación.

 Esto eliminará una dirección sin informar un error, pero esta dirección en realidad no tiene ningún significado práctico, de esta manera se puede entender que es el objeto de nodo devuelto en el montón.

Dado que es un objeto, podemos usar (punto para acceder a los miembros internos)

código superior

#include <cstdio>
#include <cstdlib>

struct node 
{
    int value;
    node *next;
};



int main()
{

    node *p_root = new node;
    node *p_next = new node;

    p_root->next = p_next;
    p_root->value = 520;

    p_next->value = 666;
    p_next->next = NULL;


    printf("%d  %d\n",p_root,*p_root);//前者是p_root在堆上的地址，后者是它在堆上引用

    //引用返回一个node对象，而不是一个指针，就用.号去访问成员
    printf("%d  %d\n",(*p_root).value,(*p_root).next);//这里注意运算符优先级顺序,点.的优先级绝对高
    /**
     *value是520,然后地址打印的是p_next指向的在堆上的地址 
     */

    return 0;
}

resultado de la operación

 

 Bueno, buenos días, buenas tardes, buenas noches.