PDF de programación - Tutorial de Apuntadores y Arreglos en C

TUTORIAL SOBRE APUNTADORES Y ARREGLOS EN C



por Ted Jensen

Versión 1.2

Febrero de 2000



El material aquí presentado está en el dominio público.

Disponible en diferentes formatos en:

http://www.netcom.com/~tjensen/ptr/cpoint.htm

– CONTENIDO –



Prefacio.................................................................................................................. 2
Introducción .......................................................................................................... 3



Capítulo 1: ¿Qué es un Apuntador? ................................................................ 4
Capítulo 2: Tipos de Apuntadores y Arreglos................................................. 9
Capítulo 3: Apuntadores y Cadenas. ............................................................... 13
Capítulo 4: Más sobre Cadenas. ...................................................................... 17
Capítulo 5: Apuntadores y Estructuras. .......................................................... 19
Capítulo 6: Más sobre Cadenas y Arreglos de Cadenas. ................................ 23
Capítulo 7: Más sobre Arreglos Multidimensionales...................................... 27
Capítulo 8: Apuntadores a Arreglos................................................................ 29
Capítulo 9: Apuntadores y Gestión Dinámica de Memoria. ........................... 31
Capítulo 10: Apuntadores a Funciones ............................................................. 38



Epílogo .................................................................................................................. 49

Traducido al español por Marte Baquerizo

[email protected]

Universidad de los Altos de Chiapas.



México.

Junio de 2003





PREFACIO



Este documento pretende dar una introducción sobre apuntadores a los programadores novatos del
lenguaje C. Después de varios años de leer y de contribuir en varias conferencias de C, incluyendo aquellas en
FidoNet y UseNet, he notado que un buen número de principiantes en C presentan dificultades en comprender
los fundamentos sobre apuntadores. Es por esto que me he dado a la tarea de tratar de explicarlos en un
lenguaje simple y con un montón de ejemplos.
La primera versión de este documento se otorgó al dominio público, al igual que esta. Fue recogida por Bob
Stout quien la incluyó como un archivo de nombre PTR -HELP.TXT en su ampliamente distribuida colección de
SNIPPETS. Desde esa edición original de 1995, he añadido una cantidad significativa de material y corregido
algunos pequeños errores.
En la versión 1.1 de HTML hice algunas correcciones en el manejo de terminología como resultado de los
comentarios que he recibido de todas partes del mundo. En la versión 1.2 he actualizado los primeros 2
capítulos para hacer notar el cambio de 16 a 32 bits en los compiladores para PC’s.

Reconocimientos:

Son tantos los que sin saberlo han contribuido a este trabajo debido a las preguntas que han publicado
en FidoNet C Echo, o en el grupo de noticias de UseNet comp.lang.c, o en muchas otras conferencias en otras
redes, que sería imposible hacer una lista de todos ellos. Agradecimientos especiales a Bob Stout quien fue tan
amable en incluir la primera versión de este archivo en sus SNIPPETS.

Sobre el Autor:

Ted Jensen es un Ingeniero en Electrónica retirado que ha trabajado tanto como diseñador de hardware
o gerente de diseñadores de hardware en el campo de almacenamiento magnético. La programación ha sido
uno de sus pasatiempos desde 1968 cuando aprendió a perforar tarjetas para ser ejecutadas en un mainframe.
(¡La mainframe tenía 64Kb de memoria magnética!).

Uso de este Material:

Todo lo que se encuentra contenido en este documento es liberado al dominio público. Cualquier
persona es libre de copiar o distribuir este material en la manera que prefiera. Lo único que pido, en caso de
que este material sea usado como material de apoyo en una clase, es que fuera distribuido en su totalidad, es
decir, incluyendo todos los capítulos, el prefacio y la introducción. También apreciaría que en ese caso, el
instructor de la clase me mandara una nota a alguna de las direcciones de abajo informándome al respecto.
Escribí esto con la esperanza de que fuese útil a otros y es por eso que no solicito remuneración económica
alguna, el único modo de enterarme en que he alcanzado este objetivo es a través de los comentarios de
quienes han encontrado útil este material.

No tienes que ser un instructor o maestro para contactarte conmigo. Apreciaría mucho un mensaje de cualquier
persona que encuentre útil este material, o de quien tenga alguna crítica constructiva que ofrecer. También
espero poder contestar las preguntas enviadas por e-mail.

Ted Jensen
Redwood City, CA 94064
[email protected]

Febrero de 2000.



2


INTRODUCCION



Si uno quiere ser eficiente escribiendo código en el lenguaje de programación C, se debe tener un
profundo y activo conocimiento del uso de los apuntadores. Desafortunadamente, los apuntadores en C
parecen representar una piedra en el camino de los principiantes, particularmente de aquellos que vienen de
otros lenguajes de programación como Fortran, Pascal o Basic.


Es para ayudar a estos principiantes en el uso de apuntadores que he escrito el siguiente material.
Para obtener el máximo beneficio del mismo, siento que es necesario que el usuario sea capaz de ejecutar el
código fuente que se incluye en los artículos. Debido a esto he intentado mantener todo el código dentro de las
especificaciones del ANSI1 para que este pueda trabajar en cualquier compilador compatible con ANSI. He
tratado de dar formato al código dentro del texto de tal manera que con la ayuda de un editor de texto ASCII
uno pueda copiar el bloque de código que interesa a un archivo nuevo y compilarlo en su sistema. Recomiendo
a los lectores el hacerlo porque esto es de gran ayuda para la comprensión del material.


1ANSI: American National Standards Institute (Instituto Nacional Americano de Estándares), definió a través del comité
X3J11 formado en 1982, el estándar del lenguaje C en 1989 y de sus funciones de librería. Esto debido a que surgieron
varias versiones del lenguaje que diferían en cuanto a características y extensiones hechas al mismo. (Nota del traductor).

3



CAPITULO 1: ¿QUE ES UN APUNTADOR?



Una de las cosas más difíciles que encuentran los principiantes en C es entender el concepto de
apuntadores. El propósito de este documento es dar una introducción sobre apuntadores y de su uso a estos
principiantes.

Me he encontrado a menudo que la principal razón por la que los principiantes tienen problemas con los
apuntadores es que tienen una muy pobre o mínima concepción de las variables, (del modo en que C hace uso
de ellas). Así que comencemos con una discusión sobre las variables de C en general.

Una variable en un programa es algo con un nombre, que contiene un valor que puede variar. El modo en que
el compilador y el enlazador (linker) manejan esto es que asignan un bloque específico de la memoria dentro de
la computadora para guardar el valor de una variable. El tamaño de este bloque depende del rango en que a
esta variable le es permitido variar. Por ejemplo, en PC’s de 32 bits, el tamaño de una variable de tipo entero
(int) es de 4 bytes, en una máquina antigua de 16 bits los enteros tienen un tamaño de 2 bytes. En C el tamaño
de un tipo de variable como una de tipo entero no tiene porqué ser el mismo en todos los tipos de máquinas. Es
más en C disponemos de diferentes tipos de variables enteras, están los enteros largos (long int) y los enteros
cortos (short int) sobre los que puedes averiguar en cualquier texto básico sobre C. El presente documento
asume que se está usando un sistema de 32 bits con enteros de 4 bytes.

Si quieres conocer el tamaño de los diferentes tipos de enteros de tu sistema, ejecutar el siguiente código te
dará la información.

#include <stdio.h>

int main()
{
printf("El tamaño de short (entero corto), es: %d\n", sizeof(short));
printf("El tamaño de int (entero), es: %d\n", sizeof(int));
printf("El tamaño de long (entero largo), es: %d\n", sizeof(long));
}


Cuando declaramos una variable le informamos al compilador 2 cosas, el nombre de la variable y el tipo de la
variable. Por ejemplo, declaramos una variable de tipo entero llamada k al escribir:


int k;


Cuando el compilador encuentra la palabra “int” de esta instrucción, reserva 4 bytes (en un PC) de memoria
para almacenar el valor del entero. También construye una tabla de símbolos. Y en esa tabla agrega el símbolo
k y la correspondiente dirección de la memoria en donde esos 4 bytes han sido reservados.

Así que si luego escribimos:


k = 2;

4


esperamos encontrar al momento de la ejecución, un 2 colocado en el área de memoria reservada para guardar
el valor de k. En C nos referimos a una variable como la de tipo entero k como un “objeto”2.

Tiene sentido decir que hay dos valores asociados con el objeto k, uno es el valor del entero alojado ahí (un 2
en el ejemplo de arriba) y el otro el “valor” de la localidad de la memoria donde se ha guardado, es decir, la
dirección de k. Algunos textos se refieren a estos dos valores con la nomenclatura rvalue (“are value”, –right
value– valor a la derecha) y lvalue (“el value” –left value– valor a la izquierda).