Apuntadores en C o C++ -Conceptos-

Hace algunos días un amigo (hola Moi!) me pidió ayuda acerca de como usar apuntadores en C++. El esta estudiando su carrera en sistemas computacionales y le pidieron hacer un programa que manejara listas, listas doblemente enlazadas, listas circulares doblemente enlazadas, y listas -con otros nombre extraños-.

El caso es que le redacté un documento breve de qué son los apuntadores, y como podría usarlos, así como darle uno que otro tip para usarlos.
Empecé a hacer memoria de lo que nos habían enseñado en el Tec, y este es el documento resultante.

- Si he cometido alguna imprecisión, por favor háganla saber ya que fueron hace algunos años que lleve 'estructura de datos' donde me vi "obligado" a aprender el lenguaje C y C++. -
Creo que el documento sí le sirvió ya que pudo terminar su programa sin problemas -tengo su acuse de recibo-.

Este es el contenido del documento:
=================================================================
Un apuntador no es más que un indicador a una dirección de memoria.

Para entender un poco esto, digamos que la memoria (La memoria RAM), tiene dos valores principales. 1. Su contenido, y 2. Su dirección.

El contenido es para saber que valor esta almacenando en la memoria.
La dirección es para saber en qué parte o ubicación de la memoria esta ese valor.

Por ejemplo, una variable guarda el valor. Un apuntador apunta la dirección.
NOTA: Con un apuntador también puedes consultar el contenido de la memoria (sin necesidad de usar una variable).

Pero a diferencia de la variable, un apuntador te da más ‘poder’ o ‘control’ sobre tus recursos, en este caso la memoria.
Con una variable puedes guardar valores fijos.
Con un apuntador tu límite es la capacidad de la memoria RAM. (es decir tu puedes usar o manejar la memoria a conforme la necesites).

Supongamos que declaras una variable de tipo char y la declaras como “chrLugar”, y le asignas el valor de “ZIHUA”.
Y supongamos que declaras un apuntador *prtLugar y apunta a la dirección donde comienza ZIHUA.
Si vemos eso en la memoria RAM seria algo asi:
Con la variable, tu accederías a ZIHUA, la variable ve como un todo, y no te interesa saber en qué parte de la memoria está siendo usada.

Si accedes a ZIHUA con un apuntador, usarías *prtLugar.
NOTA: *prtLugar te da el contenido. Con &prtLugar te da la dirección.

Para comparar y diferenciar:
Variable = chrLugar valor: ZIHUA
Apuntador= *prtLugar valor: ZIHUA
Direccion= &prtLugar valor: 1018

NOTA: Aunque el apuntador *prtLugar apunta a una dirección… realmente te devuelve el contenido.
Eso es lo básico para entender apuntadores.

Para entender listas enlazadas (de cualquier tipo, ya sea circular, doblemente enlazada, doblemente enlazada circular, etc.)

Es necesario entender dos cosas:
1 Apuntadores.
2 Estructuras (cómo definir un struct en C)

Y aparte debes de tomar en cuenta lo siguiente que es muy importante sobre todo en listas doblemente enlazadas:
El orden de insertar o agregar un elemento en la lista.
El orden de quitar o remover un elemento en la lista.

(Debe de revisarse siempre el orden en que se agrega o se remueve un elemento).

Ejemplo de una lista, supongamos que tenemos un listado de Nombres y teléfonos.
Debemos de manejar siempre un apuntador que apunte a la raiz (root) o el primer elemento.
Y debemos de tener un apuntador que hará los barridos o recorridos.



De lo anterior tenemos una lista.

Un apuntador raiz (*root) que apunta al primer elemento (Juan).
En la estructura tenemos un apuntador (*sig) que apunta al siguiente elemento.

El último elemento (Luis), su apuntador sig, apunta a NULL. Ya que no hay mas elementos en la lista.

Cuando queramos insertar un nuevo registro en la lista, debemos de buscar a “*sig” y que sea NULL, entonces a ese lo apuntaremos, de NULL al nuevo elemento.

Cuando queramos borrar un elemento, debemos de buscar el valor por ejemplo queremos borrar a Hugo, y hacemos que el apuntador de Juan, apunte a Luis. Y haciendo eso, Hugo esta removido de la lista.


Si quieres mas detalles avísame