Está en la página 1de 5

APUNTADORES

Son Variables que contienen una Direccin de Memoria, generalmente se


les simplifica diciendo que son direcciones de memoria. Normalmente, la
direccin que contiene un apuntador, es la posicin de otra Variable en la
memoria pero, podra ser la direccin de un Puerto o un Arreglo de la RAM. Si
una Variable contiene la Direccin de otra, se dice que la primera apunta a la
segunda.
Operadores
Existen dos operadores especiales para trabajar con apuntadores: &y *.
El primero devuelve la direccin de memoria de su operando. Por ejemplo, si
queremos guardar en el apuntador x la direccin de memoria de la variable
num, deberemos hacer lo siguiente:
x=#
El segundo devuelve el valor de la variable cuya direccin es contenida por el
apuntador. Este ejemplo asigna el contenido de la variable apuntada por x, es
decir num, a la variable a:
a=*x;
El buen uso de apuntadores es importante para la elaboracin de buenos
Programas, tres razones para ello:
1. Proporcionan los medios a travs de los cuales las Funciones modifican sus
argumentos en una llamada;
2. Se pueden utilizar para soportar rutinas de Asignacin Dinmica, y
3. Se pueden sustituir por Arreglos en muchas situaciones para incrementar
la eficiencia. Son una de las caractersticas mas poderosas de C pero, al
mismo tiempo, pueden ser peligrosas ya que cuando se utilizan sin
inicializar o sin control, puede ocasionar cadas del sistema.
La Declaracin de un Apuntador, se hace especificando el tipo de dato que
contendr (char, int, float, precediendo el nombre de un asterisco: char *p1, int
*p2, float *p3.
Los Operadores de Apuntadores son el * y el &. El Ampersand (&) devuelve la
direccin de memoria de su operando; el Asterisco, hace referencia al valor
contenido en la direccin asignada por el compilador.
Al hacer la asignacin: p1=&x siendo p1 un apuntador, se esta asignando la
direccin de memoria que el compilador le asign a la variable 'x' cuando fue
declarada.
Aritmtica de direcciones
Es posible desplazar un apuntador recorriendo posiciones de memoria. Para ello
podemos usar los operadores de suma, resta, incremento y decremento (+, -,
++, --) Si tenemos un apuntador (p1) de tipo int (2 bytes), apuntando a la
posicin 30000 y hacemos: p1=p1+5, el apuntador almacenar la posicin
30010, porque apunta 5 enteros por encima (10 bytes ms).
De tal forma que debemos de tener presente que, dependiendo del tipo de dato
que se haya declarado, sern los bytes que aumentara o decrementara en su
valor, nuevamente, si, por ejemplo, hacemos la siguiente declaracin: int *p, el
cual apunta a un entero con valor de 2007 y, posteriormente, se escribe:
p++, esto incrementar su valor a 2009 ya que el tipo de dato, 'int' usa 2
bytes para su representacin. En forma similar, si declaramos float *p; y
ejecutamos p++, el resultado sera: 2011; si se incrementa un Apuntador tipo
Caracter, su valor se incrementar en 1. Tambin es permitida la suma de un
Apuntador y una constante numrica entera: vg: p= p + 5.
Se pueden comparar Apuntadores en expresiones o comparaciones relacionales,
como ejemplo; suponiendo tener declarados 2 Apuntadores, se pueden comparar
entre si de la siguiente forma:
if(p1 > p2)
printf("p1 apunta a una localidad de memoria ms alta que p2);
Hay una estrecha relacin entre Apuntadores y Arreglos: Supongamos el
siguiente cdigo:
char str[8];
int*Ap;
AP=str;
La asignacin dejara en Ap la direccin del 1er. Elemento del arreglo; En
C, un nombre de Arreglo sin un ndice es la Direccin de inicio del Arreglo.
El mismo resultado se obtiene con la siguiente expresin: AP=&str[0];.
Podemos accesar en forma directa cualquier elemento del arreglo, por ejemplo,
si quisiramos accesar el 10 elemento del arreglo, tenemos 2 formas para
hacerlo: str[10] o utilizando el apuntador: *(Ap+9) ya que al estar inicialmente
sealando al 1er. elemento (posicin 0), al sumarle 9, sealar al 10 elemento.
Asignacin
Los Apuntadores se asignan igual que el resto de las variables. El programa
ejemplo mostrar las direcciones contenidas en p1 y p2, que ser la misma en
ambos apuntadores.
/ * Asignaciones de Apuntadores. */
#include <stdio.h>
#include "conio.h"
int main() / * Asignamos direcciones */
{
int a;
int *p1,*p2;
clrscr();
p1=&a;
gotoxy(25,10);
printf("%x, %p",p1,p2);
p2=p1;
gotoxy(25,12);
printf("%x, %p",p1,p2)
getch();
}
Archivo: apuntala.c
/ / Manejo de Apuntadores CHAR
#include "stdio.h"
#include "conio.h"
#define apuntador(x) printf("Direc.: &Ap=%u, Valor del Apuntador=%u, \
Contenido Ap=%c\n",&x,x,*x);
void main()
{ char a, b, *p1, *p2;
clrscr();
a='A', b='Z';
p1=&a, p2=&b;
gotoxy(10,10), printf("Resultados del acceso a datos de la memoria: ");
gotoxy(10,12), apuntador(p1); // Para hallar los datos
gotoxy(10,13), apuntador(p2); // Para Direcciones y Contenidos de los
Apuntadores
p2=p1;
gotoxy(10,15), printf("Resultados despus del intercambio de Apundadores: ");
gotoxy(10,17), apuntador(p1);
gotoxy(10,18), apuntador(p2);
gotoxy(10,20), printf("Finalmente, el contenido de p2=%c.", *p2);
getch();
}
Resultados del acceso a datos de la memoria:
Direc.: &Ap=65522, Valor del Apuntador=65525, Contenido Ap=A
Direc.: &Ap=65520, Valor del Apuntador=65524, Contenido Ap=Z
Resultados despus del intercambio de Apundadores:
Direc.: &Ap=65522, Valor del Apuntador=65525, Contenido Ap=A
Direc.: &Ap=65520, Valor del Apuntador=65525, Contenido Ap=A
Finalmente, el contenido de p2=A.
/ / Manejo de Apuntadores INT
#include "stdio.h"
#include "conio.h"
void main()
{ int a=7, b=3, *A;
clrscr();
gotoxy(15,10), printf("DIRECCIONES Y CONTENIDOS DE LAS VARIABLES 'A' Y 'B':
");
gotoxy(15,12), printf("&a=%u &b=%u a=%d b=%d ",&a,&b,a,b);
gotoxy(15,15), printf("ASIGNACIN DE APUNTADORES: A=&a y b=*A");
A=&a, b=*A;
gotoxy(15,17), printf("&A=%u A=%u &a=%u &b=%u a=%d b=%d",
&A,A,&a,&b,a,b);
getch();
}
DIRECCIONES Y CONTENIDOS DE LAS VARI ABLES 'A' Y 'B':
&a=65524 &b=65522 a=7 b=3
ASIGNACIN DE APUNTADORES: A=&a y b=*A
&A=65520 A=65524 &a=65524 &b=65522 a=7 b=7
/ / Manejo de Apuntadores FLOAT
#include "stdio.h"
#include "conio.h"
void main()
{ float a=7.33, b=3.1, *A;
clrscr();
gotoxy(10,10), printf("DIRECCIONES Y CONTENIDOS DE LAS VARIABLES 'A' Y
'B':\n\n");
gotoxy(10,12), printf("&a=%u &b=%u a=%f b=%f\n\n\n",&a,&b,a,b);
gotoxy(10,15), printf("ASIGNACIN DE APUNTADORES: A=&a y b=*A\n\n");
A=&a;
b=*A;
gotoxy(10,16), printf("&A=%u A=%u &a=%u &b=%u a=%f b=%f",
&A,A,&a,&b,a,b);
getch();
}
DIRECCIONES Y CONTENIDOS DE LAS VARI ABLES 'A' Y 'B':
&a=65522 &b=65518 a=7.330000 b=3.100000
ASIGNACIN DE APUNTADORES: A=&a y b=*A
&A=65516 A=65522 &a=65522 a=7.330000 &b=65518 b=7.330000