7.6 Aritmética
de punteros
Un
puntero apunta a una dirección de memoria.
El
lenguaje C permite sumar o restar cantidades enteras al puntero, para que
apunte a una dirección diferente:
aritmética
de punteros
.
Consideremos
un puntero a enteros:
int* ptr;
ptr
apuntará a cierta dirección de memoria:
Pero
también tendrán sentido las expresiones
ptr+1,
ptr+2,
etc. La expresión
ptr+k
es un puntero que apunta a la dirección de
ptr
sumándole
k
veces el espacio ocupado por un elemento del tipo al que apunta (en este caso un
int):
Ejemplo
de aritmética de punteros
int vector [100]; /* un vector de enteros */
int *ptr; /* un puntero a enteros */
...
ptr = &vector[0]; /* ptr apunta al principio del vector */
*ptr = 33; /* igual que vector[0] = 33 */
*(ptr+1) = 44; /* igual que vector[1] = 44 */
*(ptr+2) = 90; /* igual que vector[2] = 90 */
La
expresión que se suma al puntero ha de ser entera y no tiene por
qué ser constante. Obsérvese que
ptr
es lo mismo que
ptr+0.
La
expresión sumada NO es el número de bytes que se suman a la
dirección, es el número de elementos del tipo al que apunta el
puntero:
/* Supongamos que un "char" ocupa 1 byte */
/* y que un "double" ocupa 8 bytes */
char* ptrchar;
double* ptrdouble;
...
*(ptrchar+3) = 33; /* la dirección es ptrchar + 3 bytes */
*(ptrdouble+3) = 33.0;
/* la dirección es ptrdouble + 24 bytes,
ya que cada double ocupa 8 bytes */
El
compilador "sabe" cómo calcular la dirección según el tipo.
Aritmética
de punteros (más)
A
un puntero se le puede aplicar cualquier clase de operación de suma o
resta (incluyendo los incrementos y decrementos).
/* Rellenar de unos los elementos del 10 al 20 */
int* ptr; /* el puntero */
int vector [100]; /* el vector */
int i; /* variable contadora */
ptr = &vector[0]; /* ptr apunta al origen del vector */
ptr+=10; /* ptr apunta a vector[10] */
for ( i=0; i<=10; i++ )
{
*ptr = 1; /* asigna 1 a la posición de memoria apuntada por "ptr" */
ptr++; /* ptr pasa al siguiente elemento */
}