Cuestiones generales

Un array es un tipo de estructura de datos que consta de un número fijo de elementos del mismo tipo. En una máquina, dichos elementos se almacenan en posiciones contiguas de memoria. Estos elementos pueden ser variables o estructuras. Para definirlos se utiliza la expresión:

tipo_de_elemento nombre_del_array[número_de_elementos_del_array];
int mapa[100];

Cada uno de los elementos de los que consta el array tiene asignado un número (índice). El primer elemento tiene índice 0 y el último tiene índice número_de_elementos_del_array-1. Para acceder a ese elemento se pone el nombre del array con el índice entre corchetes:

nombre_del_array[índice]
mapa[5]

Los elementos no tienen por qué estar determinados por un solo índice, pueden estarlo por dos (por ejemplo, fila y columna), por tres (p.e. las tres coordenadas en el espacio), o incluso por más. A estos arrays definidos por más de un índice se le llaman arrays multidimensionales o matrices, y se definen:

tipo_de_elemento nombre_del_array[número1] [número2]... [númeroN];
int mapa[100][50][399];

Y para acceder a un elemento de índices i1,i2,...,iN, la expresión es similar:

nombre_del_array[i1][i2]...[iN]
mapa[34][2][0]

Hay que tener cuidado con no utilizar un índice fuera de los límites, porque dará resultados inesperados (tales como cambio del valor de otras variables o finalización del programa, con error "invalid memory reference").

Manejo de arrays

Para manejar un array, siempre hay que manejar por separado sus elementos, esto es, NO se pueden utilizar operaciones tales como dar valores a un array (esperando que todos los elementos tomen ese valor). También hay que tener en cuenta de que al definir un array, al igual que con una variable normal, los elementos del array no están inicializados. Para ello, hay que dar valores uno a uno a todos los elementos. Para arrays unidimensionales, se utiliza un for:

for(i=0;i<N;i++)
   array[i]=0;

y para arrays multidimensionales se haría así:

for(i1=0;i1<N1;i1++)
   for(i2=0;i2<N2;i2++)
    ...
      for(iN=0;iN<NN;iN++)
         array1[i1][i2]...[iN]=0;

Hay una función que, en determinadas ocasiones, es bastante útil para agilizar esta inicialización, pero que puede ser peligrosa si se usa sin cuidado: memset (incluida en string.h). Lo que hace esta función es dar, byte a byte, un valor determinado a todos los elementos:

memset(array,num,tamaño);

donde array es el nombre del array (o la dirección del primer elemento), num es el valor con el que se quiere inicializar los elementos y tamaño es el tamaño del array, definido como el número de elementos por el tamaño en bytes de cada elemento. Si el tamaño de cada elemento del array es 1 byte, no hay problema, pero si son más, la función da el valor num a cada byte de cada elemento, con lo que la salida de un programa del tipo:

#include<stdio.h>
#include<string.h>

void main()
{
   short mapa[10];
   memset(mapa,1,10*sizeof(short));
   printf("%d",mapa[0]);
}

no es 1 (0000000000000001 en base 2), como cabría esperar, sino 257 (0000000100000001 en base 2).

También hay otra función que facilita el proceso de copiar un array en otro: memcpy (incluido también en string.h). Esta función copia byte a byte un array en otro.

Arrays dinámicos

Si al iniciar un programa no se sabe el número de elementos del que va a constar el array, o no se quiere poner un límite predetermiado, lo que hay que hacer es definir el array dinámicamente. Para hacer esto, primero se define un puntero, que señalará la dirección de memoria del primer elemento del array:

tipo_de_elemento *nombre_de_array;

y luego se utiliza la función malloc (contenida en stdlib.h) para reservar memoria:

nombre_de_array=(tipo_de_elemento *)malloc(tamaño);

donde tamaño es el número de elementos del array por el tamaño en bytes de cada elemento. La función malloc devuelve un puntero void, que indica la posición del primer elemento. Antes de asignarlo a nuestro puntero, hay que convertir el puntero que devuelve el malloc al tipo de nuestro puntero (ya que no se pueden igualar punteros de distintos tipos).

Para arrays bidimensionales, hay que hacerlo dimensión a dimensión; primero se define un puntero de punteros:

int **mapa;

Luego se reserva memoria para los punteros:

mapa=(int **)malloc(sizeof(int *)*N1);

y, por último, para cada puntero se reserva memoria para los elementos:

for(i1=0;i1<N1;i1++)
   mapa[i1]=(int *)malloc(sizeof(int)*N2);

Ya se puede utilizar el array normalmente. Para arrays de más de dos dimensiones, se hace de forma similar.

Temas relacionados

- Algoritmos de ordenación

- Algoritmos de búsqueda