Arrays en C
Arrays dinámicos de una dimensión[editar]
Para crear un array de longitud variable se pueden utilizar punteros. El array se declara así
int *array;
Cuando queramos reservar espacio para él
/* En C++ */ array = new int [N]; /* En C o en C++ */ array = (int *)malloc (N*sizeof(int));
donde N es el número de elementos que queremos para el array. En C++ nos basta con indicar en el new el número de elementos. Con C debemos indicar en la fución malloc() el tamaño en bytes que deseamos para el array. Si sizeof(int) es lo que ocupa un entero, necesitamos N*sizeof(int)
Para usar el array, una vez creado, simplemente
array[i] = ...; variable = array[i];
Una vez que terminemos de usarlo, debemos liberarlo
/* Si hemos hecho new */ delete [] array; /* Si hemos hecho malloc */ free(array);
Arrays dinámicos de dos dimensiones[editar]
Para un array en dos dimensiones, debemos hacer una declaración más compleja. Un array de dos dimensiones es en realidad un array de una dimensión de punteros. Cada uno de estos punteros apuntará a otro array de una dimensión de los datos que queremos. Cada uno de estos arrays será una fila de nuestro array de dos dimensiones. La declaración, por tanto, es compleja
int **array;
Para reservar espacio, por ejemplo M filas y N columnas, debemos primero reservar espacio para el array de punteros
/* En C++ */ array = new (int *)[M]; /* En C */ array = (int **)malloc (M * sizeof(int *));
Es decir, hacemos un array de M punteros a entero, es decir, de M int *. Ya tenemos creados tantos punteros como filas, pero no las columnas. Ahora hay que crear las columnas. Las columnas se crean haciendo un array de una dimensión con tantos elementos como columnas. Para ello, debemos hacer un bucle para cada fila en el que creemos un nuevo array
/* En C++ */ for (int i=0; i<M; i++) array[i] = new int[N]; /* En C */ int i; for (i=0; i<M; i++) array[i] = (int *)malloc (N*sizeof(int));
Al final hemos construido algo como lo de la figura
Para usarlo, simplemente usamos dos corchetes
array[i][j] = valor; valor = array[i][j];
Con array[i] tenemos el puntero i que apunta a un array de una dimensión, que corresponde a la fila i. Luego con array[i][j] accedemos al elemento j de ese array[i].
Liberar esto puede ser un poco pesado. Primero debemos liberar cada uno de los arrays fila y luego el de punteros.
/* En C++ */ for (int i=0; i<M; i++) delete [] array[i]; delete [] array; /* En C */ int i; for (i=0; i<M; i++) free (array[i]); free(array);
Usar un array de una dimensión como si fuera de dos[editar]
Como los arrays de dos dimensiones son un poco engorrosos de crear y liberar, debemos hacer funciones o métodos que se encarguen de esta creación o liberación, de forma que no tengamos que copiar esas líneas de código cada vez que queramos crear o liberar un array.
Otra solución bastante habitual consiste en usar un array de una dimensión como si fuera de dos. Por ejemplo, si queremos una array de M filas y N columnas, en total son M*N elementos, así que hacemos un array simple de M*N elementos
/* En C++ */ int *array; array = new int [M*N]; /* En C */ int *array; array = (int *)malloc (M*N*sizeof(int));
Ahora, para usarlo, hacemos un truquito. Si consideramos que desde 0 hasta N-1 son la primera fila, desde N hasta 2N-1 son la segunda, etc, para acceder al elemento i,j debemos hacer esto
array[N*i + j] = valor; valor = array [N*i + j];
Veamos que esto va bien.
- Los elementos de la primera fial, con i igual a cero, serán 0*i + j, es decir 0,1,2...,N-1.
- Los elementos de la segunda fila, con i igual a uno, serán 1*i + j, es decir N,N+1,N+2,...,2N-1
- y así sucesivamente.
Liberar este array es sencillo
/* Si hemos hecho new */ delete [] array; /* Si hemos hecho malloc */ free(array);