C, usa apuntadores explcitamente con:

Arreglos,
Estructuras y
Funciones
El uso de apuntadores en C y C++ es muy importante debido a que permite hacer los
programas ms eficientes y ms flexibles. En este artculo se explica de una manera sencilla
y breve todo lo referente a la utilizacin de apuntadores tanto en C como en C++.
Todo lo explicado en este artculo aplica tanto para C como para C++, a menos que se
especifique un lenguaje en particular. En algunos ejemplos de cdigo que son aplicables a
C aparecen instrucciones de entrada y salida de las libreras estndar de C++.
LOS APUNTADORES:
Los apuntadores son variables que almacenan direcciones de memoria.
En general una variable contiene un valor especfico dependiendo de como fue
declarada.
Un apuntador contiene la direccin de una variable que contiene un valor
especfico.
Una variable se refiere directamente a un valor y un apuntador se refiere
indirectamente a un valor.
Apuntadores usados en C debido a que a veces son la nica manera de expresar un
clculo.
Se puede llegar a obtener un cdigo ms compacto y eficiente.
Cuando se emplean sin cuidado pueden crear programas imposibles de entender.
Cuentan con una declaracin propia.
Los apuntadores disponen de dos operadores: El operador unario o mondico &
devuelve la direccin de memoria de una variable; El operador de indireccin o
desreferencia * devuelve el ``contenido de un objeto apuntado por un apuntador''.
Declaracin De Apuntadores:
Cuando se declara una variable, el compilador reserva un espacio de memoria para ella y
asocia el nombre de sta a la direccin de memoria desde donde comienzan los datos de esa
variable. Las direcciones de memoria se suelen describir como nmeros en hexadecimal.
Un apuntador es una variable cuyo valor es la direccin de memoria de otra variable. Se
dice que un apuntador apunta a la variable cuyo valor se almacena a partir de la direccin
de memoria que contiene el apuntador. Por ejemplo, si un apuntador p almacena la
direccin de una variable x, se dice que p apunta a x.
Los apuntadores como cualquier otra variable deben de ser declarados antes de que
puedan ser utilizados.
El tipo de un apuntador lo proporciona implcitamente el tipo de la variable a la que
apunta.
Los apuntadores pueden ser declarados para apuntar a objetos de cualquier clase.
La sintaxis general de declaracin es:
<tipo> * <variable>
Ejemplos de declaraciones:
La variable contPtr es del tipo apuntador a entero, (int *) y se lee ``contPtr es un
apuntador a int'' o ``contPtr apunta a una variable entera''.
NOTA: Un apuntador a cualquier tipo de variables es una direccin en memoria, la
cual es una direccin entera, pero un apuntador NO es un entero.
La razn por la cual se asocia un apuntador a un tipo de dato, es por que se debe
conocer en cuantos bytes esta guardado el dato. De tal forma, que cuando se
incrementa un apuntador, se incrementa el apuntador por un ``bloque'' de memoria,
en donde el bloque esta en funcin del tamao del dato. Por lo tanto para un
apuntador a un char, se agrega un byt a la direccin y para un apuntador a entero o a
flotante se agregan 4 bytes. De esta forma si a un apuntador a flotante se le suman 2,
el apuntador entonces se mueve dos posiciones float que equivalen a 8 bytes.
Los Operadores De Los Apuntadores:
Un operador de direccin &:
Representa la direccin de memoria de la variable que le sigue; Operador unario
que regresa la direccin de su operando, ejemplo:
main()
{
int y;
int *yPtr;
y = 5;
yPtr = &y;
}
2. Un operador de indireccin o de desreferencia:
*. El operador * aplicado al nombre de un apuntador indica el valor de la variable
apuntada; Regresa el valor del objeto hacia el cual su operando apunta, es decir un
apuntador, ejemplo:
main()
{
int x,y;
int *py;
y = 5;
*py = y;
x = *py + 5;
printf(''%d %d nn'',*py,x);
}
Veamos con un ejemplo en C la diferencia entre todos estos conceptos
Es decir: int x = 25, *pint;
pint = &x;
La variable pint contiene la direccin de memoria de la variable x. La expresin:
*pint representa el valor de la variable (x) apuntada, es decir 25. La variable pint
tambin tiene su propia direccin: &pint
Inicializacin de APUNTADORES:
< Almacenamiento > < Tipo > * < Nombre > = < Expresin >
Si <Almacenamiento> es extern o static, <Expresin> deber ser una expresin
constante del tipo <Tipo> expresado.
Si <Almacenamiento> es auto, entonces <Expresin> puede ser cualquier expresin
del <Tipo> especificado.
Ejemplos:
La constante entera 0, NULL (cero) proporciona un apuntador nulo a cualquier
tipo de dato:
int *p;
p = NULL; //actualizacin
El nombre de un arreglo de almacenamiento static o extern se transforma segn la
expresin:
a) float mat[12];
float *punt = mat;
b) float mat[12];
float *punt = &mat[0];
Un cast apuntador a apuntador:
int *punt = (int *) 123.456;
Inicializa el apuntador con el entero. Esto es, en la direccin a la que apunta la
variable punt se almacena el valor 123.
Un apuntador a carcter puede inicializarse en la forma:
char *cadena = Esto es una cadena;
Se pueden sumar o restar valores enteros a las direcciones de memoria en la
forma:
(aritmtica de APUNTADORES)
static int x;
int *punt = &x+2, *p = &x-1;
Equivalencia: Dos tipos definidos como APUNTADORES a objeto P y
apuntador a objeto son equivalentes slo si P y Q son del mismo tipo. Aplicado a
matrices:
nombre_apuntador = nombre_matriz;

Operaciones bsicas
Declaracin
Los punteros se declaran con un asterisco, de esta forma:
tipo * variable;

Por ejemplo:
int* puntero;

Se dice que la variable puntero es un puntero a enteros (apunta a un entero).
Asignacin
El valor que puede adquirir un puntero es, por ejemplo, la direccin de una
variable.
El operador & devuelve la direccin de una variable:
puntero = &variable;
Desreferencia de un puntero
Se puede alterar la variable a la que apunta un puntero.
Para ello se emplea el operador de desreferencia, que es el asterisco:
*puntero = 45;
En este caso, se est introduciendo un 45 en la posicin de memoria a la que
apunta puntero.
Op Funcin Ejemplo Explicacin
(void
*)
Convierte entero a direccin (void *)0 direccin nula
* Para declarar apuntadores int *p; p es un apuntador
& Obtener direccin de.. q=&i; q apunta a i
= Asignar direccin p=q=&i; p y q apuntan a i
* Operador indireccin *p=7;
a donde apunta p almacena
un 7
++ Incremento-dato ++*p;
incrementa el valor que
apunta p
++ Incremento-apuntador *p++; incrementa apuntador p
%p Especificador tipo apuntador printf("%p",p);
imprime direccin
almacenada en p
== igualdad entre apuntadores p==q regresa falso si no son iguales
!=
desigualdad entre
apuntadores
p!=q regresa falso si son iguales
< menor, <= menor o igual p<=q
regresa falso si p es mayor
que q
> mayor, >= mayor o igual p>=q
regresa falso si p es menor
que q
sizeof
Espacio que ocupa un dato en
bytes
sizeof(void *)
tamao de cualquier
apuntador

Beneficios:
Generar elementos bajo demanda, i.e. asignacin dinmica de memoria
Manipular y recorrer grandes espacios de memoria
Generar estructuras de datos complejas
Parmetros de entrada/salida para funciones, i.e. parmetros por referencia
Dificultades:
Programacin avanzada, catica y/o complicada
Programacin ms susceptible de errores muy difciles de depurar
Dificultad para leer y comprender cdigo