Lenguaje C

Punteros

Omar Andrés Zapata Mesa

Grupo de Fenomenología de
Interacciones Fundamentales,
(Gfif)
Universidad de Antioquia
 ¿Qué es un Puntero?

 Un puntero o apuntador es una variable que

referencia una región de memoria; en otras
palabras es una variable cuyo valor es una
dirección de memoria. Si se tiene una variable
' p ' de tipo puntero que contiene una dirección
de memoria en la que se encuentra
almacenado un valor ' v ' se dice que ' p '
apunta a ' v '. El programador utilizará
punteros para guardar datos en memoria en
muchas ocasiones, de la forma que se
describe a continuación.
Ejemplo

#include<stdio.h>
int main(int argc,char *argv[]){
int *ptrID, ID;
ID = 8;
printf("%p = %p\n",ptrID,&ID);
ptrID = &ID; // puntero a ID
//miramos el valor de prtID
printf("%d\n",*ptrID);//accediendo al valor con el operador *
printf("%d\n",ptrID[0]);//accediendo al valor con el operador [ ]
// miramos las pocisiones en memoria
printf(" %p = %p \n",ptrID, &ID);
return 0;
}
 Los Operadores Punteros
Al trabajar con punteros se emplean dos
operadores especiales que son & y *.
 El primero es un operador monario y sirve
para acceder a la dirección de memoria.(Ver
ejemplo anterior)
 El segundo puede significar operador de
contenido o dirección según el contexto;
veamos el siguiente ejemplo y analicemos
cuando int a=1,*p1,*p2,*p3; se comportan
como puntero o cuando simplemente estamos
accediendo a su valor.
Ejemplo
#include<stdio.h>
//funcion que me cambio los valores del dato sin cambiar las direcciones de memoria
void cambiar_valores(int *p1,int *p2){
p1[0]=p2[0];
}
//funcion para cambiar las posiciones de memoria
void cambiar_punteros(void **x, void **y) {
void *t = *x;
*x = *y;
*y = t;
}
int main(int argc,char *argv[]){
int a=1,*p1,*p2,p3[]={2},*p4;
//imprimimo las posiciones actuales de memoria
printf("Posiciones iniciales de memoria => a=%p p1=%p p2=%p p3=%p \n",&a,p1,p2,p3);
p1=&a;
p2=p1;
p4=p3;//asignacion de array a puntero visto en la clase anterior
printf("Posiciones finales de memoria => a=%p p1=%p p2=%p p3=%p\n",&a,p1,p2,p3);
//valores de la pocison de memoria
printf(" %d %d %d %d \n",a,*p1,p2[0],*(p3+0));
//ahora quiero que los punteros cambien de valor pero que conserven su posicion
cambiar_valores(p1,p3);
//imprimimos las posiciones de memoria y deben ser distintas
printf(" p1=%p p3=%p \n",p1,p3);
//imprimimos los valores y p1 debe tener el de p3
printf(" p1=%d p3=%d \n",*p1,*p3);
//ahora quiero que p2 tenga la posicion de memoria de p4 y a la inversa ¿Es lo mismo cambiar p1 que p2? R/ si
p2[0]=1;//cambio el valor para demostrar
printf("posiciones y valores iniciales -> p2=%p *p2=%d , p4=%p *p4=%d \n",p2,*p2,p4,*p4);
cambiar_punteros(&p2,&p4);
printf("posiciones y valores iniciales -> p2=%p *p2=%d , p4=%p *p4=%d \n",p2,*p2,p4,*p4);
}
Operadores en Punteros

 Los operadores aritméticos como +,-,--,++ y

de comparación como <,>,!=,==,>=,<= pueden
ser usados en punteros para operar las
posiciones de memoria en si mas no los
valores que contienen. También el operador
lógico ! Puede ser usado para mirar si por
ejemplo la función malloc pudo asignar
memoria o si el puntero esta nulo.
Veamos el ejemplo.
 Ejemplo
#include<stdio.h>
int main(int argc,char *argv[]){
int a=1,*p1,*p2,p3[]={2,3,4,5},*p4;
p1=&a;
p2=p3;//para pasar de memoria estatica a dinámica
//veamos primero la posicion actual de memoria de uno de los punteros en decimal
printf("p1=%d p2=%d sizeof(p1)=%d\n",p1,p2,sizeof(p1));
//ahora apliquemos algunos operadores y miremos dichos valores en memoria
p1++;//por que crece y decrece en 4 su numero? R:/por que son enteros de 4 bytes, ver sizeof
printf("p1++=%d\n",p1);
p1--;
printf("p1--=%d\n",p1);
if(p1<p2) printf("p1=%d esta en una posición de memoria mas baja\n",p1);
else printf("p2=%d esta en una posición de memoria mas baja\n",p2);
//esto para que puede servir? ahora usemos el vector p2 y juguemos con la aritmetica
//veamos primero p1[0]=1
printf("p1[0]=%d p1=%d p2[1]=%d\n",*p1,p1,*(p2+1));
p1=&p2[1];//que se hizo aqui?R:/se tomo la posicion en memoria de un entero despues
p4=p2++;
printf("p1[0]=%d p1=%d p3=%d\n",*p1,p1,p3[1]);
}
Punteros a funciones

 Las funciones al igual que cualquier tipo de

dato en c tienen una posición definida en
memoria y la podemos usar, solo que hay
tener encuenta ciertas caracteríscas de las
funciones como lo son los prototipos. Los
protipos de la función son aquellos datos
caracteristicos propios de cada función como
el número de argumentos, el tipo de datos de
los argumentos y su valor de retorno.
Ej: int mifuncion(int a, doube b) y su protipo en
puntero seria int (*p)(int,double);
Ejemplo

#include<stdio.h>
#include<math.h>
double delta=0.001;
double derivar(double (f)(double),double x){
return (f(x+delta)-f(x-delta))/(2*delta);
}
int main(int argc,char *argv[]){
double x=M_PI/2;
double df=derivar(sin,x);
printf("derivada del seno en %lf = %lf\n",x,df);
}
Ejercicios

 Hacer una función que derive y que reciba los

siguientes prototipos de funciones.
 double fun(double x, double *params);
 double fun(double x,double amplitud);

 Hacer una función de integración para los

prototipos anteriores.
 Completar el código de ejemplo (math.c) visto
en clases anteriores, para que soporte
derivación de sin y cos en un punto pasado
por la linea de comandos.
Referencias
 Imagen tomada de
http://ifxperu.com/2011/03/programando-en-c-sharp-%E2%80%9
 Imagen tomada de
http://chuwiki.chuidiang.org/index.php?title=Arrays_en_C
 http://es.wikibooks.org/wiki/Programaci%C3%B3n_en_C%2B%2B
