Cita: Intentando descifrar las líneas:
la número 9 es que el apuntador *p accede a la dirección & de memoria de a y a su valor.
no es que *p acceda a la memoria de "a", es que en la memoria de "p" se guarda la direccion de memoria de "a" y en la direccion de memoria de "a" se guarda un numero (en este caso el 3). por eso se dice que "p" apunta a "a".
int *p=&a;
int *p es declarar un puntero llamado "p". & es la direccion de memoria. por lo que si pones &a esta devolviendo la direccion de memoria de "a" (es decir donde esta alojada "a". por ejemplo la direccion 2000h).
Cita: No entiendo el motivo por el cual ya no podemos poner & delante de p y b en las líneas 11 y 13. Entiendo que deberíamos colocar & delante de objetos que están en memoria y b lo está. Si se hace de otra manera da problemas de compilación.
cuando tu declaras un puntero:
int *p = _ aqui tiene que ir una direccion de memoria que la puedes poner de dos maneras:
&a o q (otro puntero), como "q" ya es una direccion de memoria no hace falta poner &.
en la linea 13 es diferente:
*q = b;
en este caso no esta haciendo que "q" apunte a "b". lo que esta haciendo es escribir el valor de b (un numero) en la direccion de memoria donde apunta "q". si por ejemplo "q" apunta a "a" , "a" va a valer lo que vale "b" (un numero).
esto es lioso por que se confunde con esto:
int *q = &b => declara puntero "q" que apunta a "b"
*q=b => escribe el valor de b donde apunta "q"
int *q = &b; esto es igual a esto:
int *q;
q = &b;
cuando hay un int (para declarar) el asterisco solo indica que es un puntero (para diferenciarlo de las declaraciones de una variable normal)
pero cuando NO hay un int el asterisco indica que te refieres a donde apunta el puntero (si apunta a "b" pues a "b")
#include <stdio.h>
#include <stdlib.h>
int main(void)
{
int a = 3;
int b = 1;
printf("El valor de a es %d\n", a);
int *p = &a;
crea un puntero "p" que apunta a "a"
printf("El valor de *p es %d\n", *p);
*p es el valor que hay en la zona de memoria donde apunta "p" (es decir imprime el valor de "a")
int *q = p;
crea un puntero "q" que apunta al mismo sitio que "p" (en este caso a "a")
printf("El nuevo valor de *q es %d\n", *q);
*q es el valor que hay en la zona de memoria donde apunta "p" (es decir imprime el valor de "a")
*q = b;
escribe el valor de "b" que es 1 en la zona de memoria donde apunta "q", como "q" apunta a "a", escribe 1 en "a". es decir "a" pasa a ser 1
printf("El valor de *q es ahora %d\n", *q);
con lo cual si imprimes *q imprimira el valor de "a" que ahora es el mismo que "b" (1)
return 0;
}