Apuntadores

Los apuntadores son variables que contienen direcciones en la memoria

(similar al índice de un libro que nos indica la página donde esta definido el término)

int a[5] = {2000, 3000, 4000, 5000, 6000};

int *pt;
pt = a;

 El operador * es aplicado a un puntero y nos da el valor de la variable referencia.

 El operador & se aplica a variables comunes, nos da la dirección de memoria de variable
a la que se aplica.
https://www.youtube.com/watch?v=3GO-
KckDmiM
 Apuntadores (Punteros)
 Una variable de tipo apuntador contiene una dirección de memoria.
 La dirección de memoria señalada por el apuntador es la que contiene el
dato de cualquier tipo, incluso void.
entero
Asigna la dirección de entero a
Pentero 548
int entero, *Pentero;
Pentero entero
entero = 548;
Pentero = &entero; 548
*Pentero = -234;

Pentero entero
NOTA: a los apuntadores solo se
les puede asignar: 0, NULL o una -234
dirección
 Ejemplo
#include <stdio.h>

main(){
int entero;
int *pentero;
entero = 548;
pentero = &entero;
printf("La dirección de entero es %d\n",&entero);
printf("el valor de pentero es %d\n",pentero);
printf("el valor de entero es %d\n",entero);
printf("el valor de *pentero es %d\n",*pentero);
*pentero = -234;
printf("el valor de entero es %d\n",entero);
printf("el valor de *pentero es %d\n",*pentero);
return 0;
}
Sí se define short *pt; un short se representa por 2 bytes (sizeof(short) = 2):

De igual manera sí se define float *pt; (sizeof(float) = 4):

int a = 1, b = 2, c[10] = {10, 15, 20, 25, 30, 35, 40, 45, 50, 55};
int *pt; Aquí el puntero se define pero no la variable referenciada, se debe inicializar el puntero.

pt = &a; Se inicializa el puntero "pt" con una direcció válida, la direccíón de la variable "a". Se dice a partir de aquí que "pt" apunta a
"a" o que la variable referenciada por "pt" coincide con "a". El valor de la variable refernciada por "pt" (*pt) es 1 (el mismo valor que
tiene la variable "a").

*pt = 73; Se modifica el valor de la variable referenciada, ahora *pt tiene el valor de 73. La variable "a" también cambia a 73.

b = *pt; La variable "b" ahora tiene el valor de 73.

pt = NULL; El puntero "pt" apunta ahora a NULL, ya no existe a partir de aquí la variable referenciada.
*pt = 25; ERROR: No existe la variable referenciada en este punto.

pt = c; "c" es un arreglo, por lo tanto el identificador "c" está relacionado con la dirección del primer elemento del arreglo. Esta
instrucción hace que "pt" apunte a esa misma dirección de memoria.

*pt = 88; Modifica el elemento "c[0]" en 88.

pt[0] = 88; Equivale a la enterior sentencia, modifica el elemento "c[0]" en 88.

pt[2] = 51; Modifica el elemento "c[2]" en 51. Un puntero puede manejarse como un arreglo.

pt = &c[3]; El puntero "pt" apunta al cuarto elemento de c.

*pt = 102; Modifica el elemento "c[3]" en 102.

pt[0] = 102; Equivale a la enterior sentencia, modifica el elemento "c[3]" en 102.

pt[2] = 59; Modifica el elemento "c[5]" en 59.

 Aritmética de apuntadores
Un puntero contiene una dirección de memoria que no es otra cosa que un valor entero, por lo tanto
podríamos sumar o restar valores enteros a un puntero de modo que el puntero pueda apuntar a la
memoria que se encuentre antes o después de la dirección asignada. Las siguientes instrucciones
muestran operaciones válidas para un puntero:
int c[10] = {10, 15, 20, 25, 30, 35, 40, 45, 50, 55};
int *pt;
pt = c;
pt++;
pt += 5;
pt -= 3;
pt--;
La operación que se realiza no es totalmente transparente. Es decir que "pt++;" no suma 1 al
puntero pt, ni que "pt += 5;" sume 5 a pt, ni que "pt -= 3;" ó "pt--;" reste 3 ó 1 al puntero pt
respectivamente.
Cuando se ejecuten esas órdenes el compilador multiplicará el valor que se desea añadir o restar al
puntero por el tamaño de la variable referenciada:
pt++; → El compilador lo traduce como: pt += 1*sizeof(int);
pt += 5; → El compilador lo traduce como: pt += 5*sizeof(int);
pt -= 3; → El compilador lo traduce como: pt -= 3*sizeof(int);
pt--; → El compilador lo traduce como: pt -= 1*sizeof(int);
Los apuntadores pueden utilizarse para acceder a los elementos de un arreglo.

#include <stdio.h>

main(){
int a[10]={3,4,1,8,2,3,4,5,7,0};
int *b;
b = a; //b apunta al inicio del arreglo a
printf("la dirección de b %d, contiene %d\n",b,*b);
b = b + 1; //b apunta a a[1]
printf("la dirección de b %d, contiene %d\n",b,*b);
b = b + 3; //b apunta a a[4]
printf("la dirección de b %d, contiene %d\n",b,*b);
b = b – 2; //b apunta a a[2]
printf("la dirección de b %d, contiene %d\n",b,*b);
return 0;
}
#include <stdio.h>

main(){
double a[10]={3,4,1,8,2,3,4,5,7,0},*b;
b = a;//b apunta al inicio del arreglo a
printf("la dirección de b %d, contiene %lf\n",b,*b);
b = b + 1;//b apunta a a[1]
printf("la dirección de b %d, contiene %lf\n",b,*b);
b = b + 3;//b apunta a a[4]
printf("la dirección de b %d, contiene %lf\n",b,*b);
b = b - 2;//b apunta a a[2]
printf("la dirección de b %d, contiene %lf\n",b,*b);
return 0;
}
 Apuntadores y subíndices
La aritmética de apuntadores y los subíndices ¡son equivalentes!

#include <stdio.h>

main(){
double a[10]={3,4,1,8,2,3,4,5,7,0};
double *b;
int i;
b = a; //b apunta al inicio del arreglo a
for(i=0; i<10; i++)
printf("a[%d]=%lf\n", i, a[i]);
for(i=0; i<10; i++)
printf("*(b+%d)=%lf\n", i, *(b+i));
return 0;
}
¿Que valores tienen las variables?
int x, *px:
x *px y *py
float y, *py;
x = 5;
px = &x;
*px = 2*x + *px;
y = x;
py = y;
y = *py + x;

printf(“*p = %d x = %d\n”,*px,x);
printf(“*p = %f x = %f\n”,*py,y);
 Tarea
Suponga la siguiente declaración:
float n1 = 7.3, n2;
Escriba una sentencia para cada una de las siguientes
acciones:
 Declare ptrF como un apuntador a un objeto tipo float
 Asigne la dirección de n1 a ptrF
 Despliegue el valor del objeto apuntado por ptrF
 Asigne el valor del objeto apuntado por ptrF a n2
 Despliegue el valor de n2
 Despliegue la dirección de n1
 Despliegue la dirección almacenada en ptrF
 Asigne a ptrF la dirección de n2
 Asigne al valor del objeto apuntado por ptrF el valor
8.1
 Despliegue el valor de n1
 Despliegue el valor de n2
 ¿Que salida esperan?

#include <stdio.h>

int main(void)
{
char ch = 'c';
char *chptr = &ch;
int i = 20;
int *intptr = &i;
float f = 1.20000;
float *fptr = &f;
char *ptr = "Soy una Cadena";
printf("\n [%c], [%d], [%f], [%c], [%s]\n", *chptr, *intptr, *fptr, *ptr, ptr);
return 0;
}