Cambiar el puntero a una matriz para obtener un determinado elemento de la matriz

Question

Comprendo el sentido global de los punteros y referencias(o al menos eso creo yo), también entiendo que cuando yo uso nuevo Yo soy la asignación dinámica de memoria.

Mi pregunta es la siguiente:

Si yo fuera a utilizar cout << &p, podría mostrar el "virtual ubicación de la memoria" de p.Hay una manera en la que podía manipular este "virtual ubicación de la memoria?"

Por ejemplo, el código siguiente se muestra una matriz de ints.

Si yo quería mostrar el valor de p[1] y yo sabía que la "memoria virtual" ubicación de p, podría de alguna manera hacer "&p + 1"y obtener el valor de p[1] con cout << *p, que se apuntan ahora al segundo elemento de la matriz?

int *p;
p = new int[3];

p[0] = 13;
p[1] = 54;
p[2] = 42;

Answer 1

Seguro, usted puede manipular el puntero para acceder a los diferentes elementos de la matriz, pero se necesita para manipular el contenido del puntero (es decir,la dirección de lo que p apunte a), en lugar de la dirección del puntero.

int *p = new int[3];
p[0] = 13;
p[1] = 54;
p[2] = 42;

cout << *p << ' ' << *(p+1) << ' ' << *(p+2);

Cada uno la suma (o resta) significa que el posterior (antes) elemento de la matriz.Si p apunta a un 4 bytes de la variable (por ejemplo, int en típico de 32 bits PCs) en la dirección de decir 12345, p+1 punto a 12349, y no 12346.Nota usted desea cambiar el valor de lo que p contiene antes de eliminar la referencia a acceder a lo que apunta.

Answer 2

No del todo. &p es la dirección del puntero p. &p+1 se hará referencia a una dirección que es uno int* además, a lo largo.Lo que quiero hacer es

p=p+1; /* or ++p or p++ */

Ahora, cuando usted hace

cout << *p;

Usted recibirá 54.La diferencia es, p contiene la dirección del inicio de la matriz de enteros, mientras que &p es el dirección de p.Para mover un elemento a lo largo de, usted necesita para punto más adelante en el matriz int, no a más a lo largo de la pila, que es donde p vidas.

Si sólo hubiera &p entonces usted necesita para hacer lo siguiente:

int **q = &p; /* q now points to p */
*q = *q+1;
cout << *p;

Que también la salida 54 si no me equivoco.

Answer 3

Ha sido un tiempo (muchos años), desde entonces he trabajado con los punteros, pero sé que si p apunta al principio de la matriz (es decir,p[0]) y se incrementa (es decir,p++) entonces p ahora apunta a p[1].

Creo que usted tiene de la referencia p para obtener el valor.Usted desreferenciar un puntero por poner un * delante de él.

Así que *p = 33 con el cambio de p[0] 33.

Supongo que para conseguir el segundo elemento que le de uso *(p+1) por lo que la sintaxis que se necesitaría sería:

cout << *(p+1)

o

cout << *(++p)

Answer 4

Me gusta hacer esto:

&p[1]

A mí me parece más limpio.

Answer 5

Pensar en "tipos de puntero" en C y C++ como el que se establecen una muy larga, lógico fila de celdas superpuestas en los bytes en el espacio de memoria de la CPU, a partir del byte 0).El ancho de cada celda, en bytes, depende del "tipo" del puntero.Cada tipo de puntero pone downs una fila con diferentes anchos de celdas.Un "int *" puntero establece una fila de 4 bytes células, ya que el almacenamiento de la anchura de un int ocupa 4 bytes.Un "double *" establece un 8 bytes por la fila de la celda;un "struct foo *" puntero establece una fila con cada célula de la anchura de un solo "struct foo", independientemente de cual sea.La "dirección" de cualquier "cosa" es el desplazamiento de bytes, empezando en 0, de la celda en la fila de la celebración de la "cosa".

Aritmética de punteros se basa en las celdas de la fila, no en bytes. "*(p+10)"es una referencia a la 10 de la célula pasado "p", donde el tamaño de la celda se determina por el tipo de p.Si el tipo de "p" es "int", la dirección de "p+10" es de 40 bytes pasado p;si p es un puntero a una estructura de 1000 bytes, "p+10" es de 10.000 bytes pasado p.(Tenga en cuenta que el compilador va a elegir un tamaño óptimo para una estructura que puede ser más grande de lo que se podría pensar;esto es debido a la "relleno" y "alineación".El 1000 bytes struct discutido en realidad podría tomar 1024 bytes por celda, por ejemplo, la "p+10" en realidad sería 10,240 bytes pasado p.)