C++ asignación de puntero

Question

¿Por qué 90 es el valor de salida de y y q? Acabo de hacer p=q. ¿Cómo es que se cambia el valor de q?

int main() 
{ 

    int x; 
    int y; 
    int *p = &x; 
    int *q = &y; 

    x = 35; 
    y = 46; 

    p = q; 

    *p = 90; 

    cout << x << " " << y << endl; 
    cout << *p << " " << *q << endl; 
    cout << "Address of p = " << p << endl; 
    cout << "Address of q = " << q << endl; 

    return 0; 
} 

La salida es:

35 90 
90 90 
Address of p = 0xbffa83c0 
Address of q = 0xbffa83c0 

Answer 1

Me gustaría compartir una técnica general que he usado para aprender cómo funcionan los punteros cuando estaba empezando a cabo. Si lo aplica a su problema, verá la respuesta tan clara como el día.

Coge una hoja grande de papel milimetrado y colócala longitudinalmente sobre la mesa que tienes delante. Esta es la memoria de tu computadora. Cada caja representa un byte. Elija una fila y coloque el número "100" debajo del cuadro en el extremo izquierdo. Esta es "la dirección más baja" de la memoria. (Elegí 100 como un número arbitrario que no es 0, puede elegir otro.) Numere los cuadros en orden ascendente de izquierda a derecha.

 
+---+---+---+---+---+-- 
| | | | | | ... 
+---+---+---+---+---+-- 
100 101 102 103 104 ... 

Ahora, solo por el momento, imagina que un int tiene un byte de tamaño. Eres una computadora de ocho bits. Escriba su int a en una de las casillas. El número debajo del cuadro es su dirección. Ahora elija otro cuadro para contener int *b = &a. int *b es también una variable almacenada en algún lugar de la memoria, y es un puntero que contiene &a, que se pronuncia "dirección de a".

int a = 5; 
int *b = &a; 

 
    a  b 
+---+---+---+---+---+-- 
| 5 | |100| | | ... 
+---+---+---+---+---+-- 
100 101 102 103 104 ... 

Ahora usted puede utilizar este modelo para trabajar visualmente a través de cualquier otras combinaciones de valores y punteros que se ven. Es una simplificación (porque como dirán los pedantes del lenguaje, un puntero no es necesariamente una dirección, y la memoria no es necesariamente secuencial, y hay pila y pila y registros, etc.), pero es bastante buena analogía para el 99% de las computadoras y microcontroladores.

Así, en su caso,

int x = 35; 
int y = 46; 

 
    x y 
+---+---+---+---+---+-- 
| 35| 46| | | | ... 
+---+---+---+---+---+-- 
100 101 102 103 104 ... 

int *p = &x; 
int *q = &y; 

 
    x y p q 
+---+---+---+---+---+-- 
| 35| 46|100|101| | ... 
+---+---+---+---+---+-- 
100 101 102 103 104 ... 

p = q; 

 
    x y p q 
+---+---+---+---+---+-- 
| 35| 46|101|101| | ... 
+---+---+---+---+---+-- 
100 101 102 103 104 ... 

*p = 90; 

 
    x y p q 
+---+---+---+---+---+-- 
| 35| 90|101|101| | ... 
+---+---+---+---+---+-- 
100 101 102 103 104 ... 

Ahora lo que es *p? ¿Cuál es *q?

Answer 2

Debido q es la dirección de y. Y después de p=q, p también se convierte en la dirección de y. Es por eso que p y q imprimen la misma dirección cuando los imprime usando cout.

En otras palabras, tanto p como q apuntan a la misma variable y. Entonces, si cambia el valor de cualquiera de y, *p o *q, entonces el cambio ocurrirá en total, ¡porque todos son iguales!

Answer 3

El valor de q no cambió, q todavía señala y. Sin embargo, p apunta a y también después de p = q, entonces *p es esencialmente y, y *p = 90 asigna a y.

Tenga en cuenta que cout << "Address of p = " << p << endl; es engañosa: p y la dirección de p son dos bestias diferentes.

Así que su código se ejecuta la siguiente manera:

int main() { 

    int x; 
    int y; 
    int *p = &x; // now p points to x 
    int *q = &y; // now q points to y 

    x = 35; 
    y = 46; 

    p = q;  // now p is the same as q, i.e., points to y 

    *p = 90;  // p points to y, so *p is y. 
       // so we assign 90 to y 

    cout << x << " " << y << endl; 
    cout << *p << " " << *q << endl; // both *p and *q are y 
    cout << "Address of p = " << p << endl; 
    cout << "Address of q = " << q << endl; 

    return 0; 
} 

Answer 4

Cuando establece p=q, ambos hacen referencia a la misma ubicación de memoria. Por lo tanto, si cambia el valor apuntado por p, también cambiará el valor apuntado por q, que es la dirección de y. Por lo tanto, la salida de y, *p y *q son las mismas.

Answer 5

después de ejecutar 'p = q;' enunciado, los dos apuntadores apuntan a la misma variante 'y'. Entonces al ejecutar '* p = 90;', el valor de la variante 'y' cambia.

Answer 6

Primero define p como un puntero que apunta a x. Y luego define q como un puntero que apunta a y. Luego, escribiste p = q, entonces ahora, p y q ambos apuntarán a y.

OK, cambiar * p, significa cambiar y. luego asigna 90 a y por la línea * p = 90;

Ahora, usted tiene esto:

• y: 90
• p apunta a Y
• puntos q ay
• * t: 90
• * q: 90

Answer 7

int x;int y;int *p = &x;int *q = &y;x = 35;y = 46; 

Ie p point s a x (35) y Q puntos a y (46)

p = q; 

Ahora p puntos a y (46)

*p = 90; 

Ahora el contenido de p (también conocido como y) = 90

Ahora x = 35, y = 90, p y q punto a y

cout << x << " " << y << endl; 

Prints x, y es decir, 35 y 90

cout << *p << " " << *q << endl; 

p y q punto a la misma cosa - y - cuyo valor es 90 por lo tanto, 90 y 90 es la salida

cout << "Address of p = " << p << endl;cout << "Address of q = " << q << endl; 

Como p y q son la misma dirección hará salir el mismo valor.

Answer 8

Bueno vamos a mirarlo después de cada paso:

int x; 
int y; 

Ahora tenemos dos variables x y y:

int *p = &x; 
int *q = &y; 

No se declaran otras dos variables, puntero p que apunta a la variable x y contiene su dirección y puntero q que apunta a la variable y y contiene su dirección:

x = 35; 
y = 46; 

Aquí asignar valores a las variables, esto es clara:

p = q; 

Ahora se asignan dirección almacenada en q a variables p para que ambos puntos variables de abordar en q lo que es la dirección de y:

*p = 90; 

Aquí desreferenciar p, que es variable en la dirección en p y es y y asigne el valor 90 a la variable y.

Answer 9

Ver anotations:

int main() 
{ 
int x; 
int y; 
int *p = &x; 
int *q = &y; 

x = 35; 
y = 46; 

p = q;  // at this point p is now pointing to the same memory address 
      // as q, both of them are pointing to the memory allocated to y 

*p = 90; // this will also change the values in *q and y 

cout << x << " " << y << endl; 
cout << *p << " " << *q << endl; 
cout << "Address of p = " << p << endl; 
cout << "Address of q = " << q << endl; 

return 0; 
}