Los arrays (también llamadas vectores, tablas, matrices...), son una forma de almacenamiento de variables, que guardan una relación entre sí. Es decir, son un conjunto de variables, que se las pone el mismo nombre porque están relacionadas de alguna manera. En este tutorial trataremos su uso, definición, usos que se les pueden dar y demás utilidades para las que nos puedan servir. Debido a la longitud del mismo, se ha decidido dividirlo en dos partes.

¿Qué son las arrays?

Podríamos definir el término array como un grupo de varibales que tienen en las que el tipo y alguna característica más las hace comunes al grupo.

La definición más simple de array sería la siguiente:

tipo nombre[índice];

Donde tipo, iría el tipo del que queramos que sean nuestras arrays (int, float...); donde nombre, el identificador que queramos ponerle a nuestra array; y donde índice iría el número de elementos que constituiran el array. Cabe destacar que los índices siempre empiezan por 0 salvo cuando es una definición. Es decir, si definimos:

int nombrearray[10];

Estarmeos creando 10 elementos, pero si esto fuese una llamada, llamaríamos el elemento 11 y no al 10.. Esto hay que tenerlo mucho en cuenta para no malgastar espacio.

Las arrays se dividen en filas y columnas. Las dimensiones se verán más adelante.

Hay una característica de las arrays, y dicha característica es que SIEMPRE se pasan por referencia y no por valor a las funciones. Si no lo entiendes, te recomiendo ver este tutorial o la próxima entrega de punteros.

Las arrays tienen sus características y limitaciones que veremos más adelante.

Una de las limitaciones más importantes sobre arrays en C es que no podremos crear un array de la forma convencional habiendo, por ejemplo, preguntado primero la cantidad de colores y luego poner ese valor en la definición. Es decir, debemos crear suficientes elementos para estar seguros que podremos utilizar el programa sin problemas. Esta carencia se puede solucionar mediante punteros, pero eso se verá más adelante en otro tutorial.

Seguro que con un ejemplo se comprende todo mejor, así que ahí va un ejemplo simple que utiliza arrays.

Supongamos que tenemos que hacer un programa que sume el dinero que nos han dado nuestros amigos para comprar un regalo a alguien. Esto, en vez de tener que poner cada cantidad en una variable diferente, lo podemos ubicar en un array. Aquí el programa:

#include <stdio.h>
 
int main(){
   /*Definiciones de variables*/
   float dinero[40];
   int noamigos = 0;
   float total;
   int i, pausa;
 
   printf("Hola! Este programa sirve para calcular una suma de diferentes valores.");
 
 
   /*Peticion de datos*/
   printf("\n\nPor favor, en primer lugar dime el numero de amigos que sois: ");
   scanf("%d", &noamigos);
 
   printf("\nA continuacion introduce las diferentes cantidades a sumar:\n\n");
   for (i = 0; i < noamigos; i++){
      printf("Introduce la cantidad numero %i: ", i + 1);
      scanf("%f", &dinero[i]);
      printf("\n");
   }
 
   /*Suma de valores*/
   total = 0;
 
   for (i = 0; i < noamigos; i++)
      total += dinero[i];
 
   printf("La suma de todos los valores es: %g", total);
   printf("\n\nGracias por usarme. Adios!");
   scanf("%d", pausa);
   return 0;
}

El programa nos muestra un saludo, pide unos valores y calcula el resultado.

En la explicación solo se explicará lo nuevo, pues no vamos a perder tiempo en explicar qué es un comentario y un #include:

float dinero[40];

Como bien vimos antes, se trata de una simple definición de array unidimensional (más tarde veremos que es eso de unidimensional, bidimensional...).

dinero[i]

Esto aparece muchas veces en el código, se trata de una simple aparición de un elemento del array en una sentencia. Cabe destacar que la 'i' es otra variable ya existente con un valor predesignado. Es decir, al igual que hemos puesto la i, podríamos haber puesto en su lugar lo siguiente:

dinero[2]

ropa[5]

#define ROJO 3
 
...
 
{
 
...
 
color[ROJO]
 
...
 
}

La utilidad que tiene esto es que accedes al elemento del array y lo empleas como lo harías con una variable. En resumidas cuentas, en este ejemplo, cada elemento del array es una variable, pero se agrupan por tener algo en común.

Como veis, es mucho más sencillo de lo que parece tratar con arrays programando cosas básicas con ellas, pero más adelante nos daremos cuenta de que no todo lo que se hace con arrays son campos de rosas...

Dimensiones

Las arrays pueden ser de diferentes tipos. Olvidémonos del clásico tipo que conocíamos hasta ahora, estilo int, float, char... (aunque esto también importa mucho en una array). El tipo de una array depende del número de dimensiones que tenga. Una dimensión en las arrays no son los típicos ejes x, y, z; aunque no te vendrá mal pensar en ellos cuando te toque utilizarlas.

Así, una array unidimensional sería 1D, es decir, una tira de variables; una bidimensional sería 2D, o lo que es lo mismo, 2 o más tiras de variables paralelas las unas a las otras, que también podemos representarlas como un grupo de arrays unidimensionales; una array multidimensional de 3 dimensiones sería 3D, que podría representarse como varias tiras de variables colocadas en paralelo, y a su vez que encima tiene varias tiras de variables colocadas en paralelo, o lo que es lo mismo, un grupo de arrays bidimensionales; y así sucesivamente (4 dimensiones sería un grupo de las de 3 dimensiones).

Por cada fila del array, habrá x columnas.

Es decir, si creamos una array bidimensional de dos filas(2 dimensiones, dos filas) de 25 elementos, en realidad estaremos creando 50 variables. Por lo tanto, si creamos una array multidimensional con 3 dimensiones y 10 filas (3 grupos de arrays bidimensionales con a su vez 10 filas) de 70 elementos estaremos creando 2100 variables diferentes.

Según el número de dimensiones distingimos:

• Unidimensional: 1 fila (dimensión)
• Bidimensional: 2 dimensiones
• Multidimensional: 3 o más dimensiones

Si no has entendido el tema de las dimensiones, estas imágenes lo aclararán:

*Esta imagen representaría un array bidimensional.

*Ejemplo de array tridimensional. Observar que son varias arrays bidimensionales apiladas.

NOTA: En las arrays tridimensionales han de colocarse delante del número de celda ( [1][1], [1][2] etc ) el número del array tridimensional ( [1][1][1], [2][1][1] etc ). Para más información sobre ellas, ver su parte correspondiente en este tutorial.

NOTA 2: Para ver un array unidimensional basta con ver la primera tira de array de las bidimensionales.

Cómo usar las distintas dimensiones

Se explicarán las bidimensionales y las tridimensionales. El resto se supone que se sobreentenderán como funcionan. Las unidimensionales se han tratado ya en el primer ejemplo.

Bidimensionales

Su uso es similar al de un eje de coordenadas compuesto por x, y.

Para definir una array bidimensional, es similar al de una unidimensional pero con un corchete más.

tipo nombrearray[índice 1][índice 2];

En tipo iría el típico char, int, float... En nombrearray iría el nombre (identificador) que deseemos ponerle al array. Por último, índice 1 e índice 2 indican el número de "celdas" que tendrá nuestro array (si no entiendes qué es una fila o columna, piensa en un tablero de ajedrez o mira las imágenes anteriores).

Un array se puede inicializar poniendo entre corchetes y separados por comas los valores de cada celda del array:

int array[5] = { 1, 5, 3, 6, 3 };

A continuación veremos un ejemplo que solucionará las dudas que nos queden. Imaginemos que somos los organizadores de un concurso y queremos calcular la media de los examenes de dos personas para descubrir el ganador. Crearemos un programa que realice lo anterior, indicando la media de cada persona y quien tiene mayor puntuacion.

Definiremos un array bidimensional de 2*10 (recuerda que en C los índices empiezan en 0, por lo que en el ejemplo pondremos 1 y 9 respectivamente) que equivaldrá a las 2 personas con sus respectivas notas. También crearemos un array unidimensional de 2 "slots" (por llamarlos de alguna manera), que hará el papel de almacenar las medias de ambas personas. El programa preguntará el número de notas por persona, las almacena en sus respectivos lugares y posteriormente llama a la funcion computarmedia que se encargará de terminar el proceso. Además, crearemos un margen de error por si se introduce un número de notas superior a 10, que forzará la salida del programa.

/*Creado por: P22
Para: Scenebeta*/
 
#include <stdio.h>
 
int main(){
   //Definiciones
   float puntuacion[1][9];
   float media[1];
   int i, n, nnotas = 0;
 
   media[0] = 0;
   media[1] = 0;
 
   //Declaración de la función
   void computarmedia( float puntuacion[][], float media[], int nnotas );
 
   printf("Hola! Vamos a calcular la media de notas de dos personas y calcular cual es mejor\n");
 
   //Petición de notas
   printf("En primer lugar: Cuantas notas va a tener cada persona? ");
   scanf("%d", &nnotas);
 
   if( nnotas >= 9 ){
      printf("\nERROR: Numero fuera de rango. Adios!");
      return 1;
   }
 
   for(n = 0; n < 2; n++){
       printf("\n");
       for( i = 0; i < nnotas; i++ ){
         printf("\nIntroduce la nota numero %d de la persona numero %d: ", i + 1, n + 1);
         scanf("%f", &puntuacion[n][i]);
        }
   }
 
   computarmedia( puntuacion, media, nnotas );
 
   system("PAUSE");
   return 0;
}
 
void computarmedia( float a[1][9], float b[1], int nnotas ){
   int i, n;
 
   for( n = 0; n < 2; n++ ) for( i = 0; i < nnotas; i++ ) b[n] += a[n][i];
 
   b[0] = b[0] / nnotas;
   b[1] = b[1] / nnotas;
 
   printf("\nLa puntuacion media de la primera persona es: %.2f", b[0]);
   printf("\nLa puntuacion media de la segunda persona es: %.2f\n", b[1]);
 
   if( b[0] > b[1] ) printf("\nEl primero ha sacado mejor puntuacion\n\n");
   else printf("\nEl segundo ha sacado mejor puntuacion\n\n");
 
   return;
}

En primer lugar se incluye la librería stdio.h y se crea la función principal.

//Definiciones
float puntuacion[1][9];
float media[1];
int i, n, nnotas = 0;
 
media[0] = 0;
media[1] = 0;

Después se procede a definir las variables que se emplearán en el programa. Así 'puntuacion' (guardará será un array bidimensional de 2 columnas por 10 filas de tipo float; 'media' (que almacenará la media de cada alumno) es un array unidimensional de dos celdas; por último, se definen 'i', 'n' y 'nnotas' (número de notas) como variables tipo int, inicializando esta última con un valor de 0.

//Declaración de la función
void computarmedia( float puntuacion[][], float media[], int nnotas );

Esto podría parecer confuso con una de las líneas que veremos posteriormente. Se ha creado una declaración de la función computarmedia, que no devuelve nada (void). Además tiene 3 argumentos formales: un array bidimensional de tipo int, otra unidimensional de tipo float y por último otra de tipo int. Has de recordar que los nombres de los argumentos son simbólicos, es decir, que al igual que hemos puesto 'int puntuacion[][]' podríamos haber escrito 'int P22[][]' o 'int scenebeta[][]' . Los argumentos NO han de llevar el índice.

   //Petición de notas
   printf("En primer lugar: Cuantas notas va a tener cada persona? ");
   scanf("%d", &nnotas);
 
   if( nnotas >= 9 ){
      printf("\nERROR: Numero fuera de rango. Adios!");
      return 1;
   }

De lo más sencillo, ya deberíamos estar hartos de verlo. Se pide un valor para nnotas y se comprueba si es mayor a 10. En caso de serlo se cierra el programa.

   for(n = 0; n < 2; n++){
       printf("\n");
       for( i = 0; i < nnotas; i++ ){
         printf("\nIntroduce la nota numero %d de la persona numero %d: ", i + 1, n + 1);
         scanf("%f", &puntuacion[n][i]);
        }
   }

Aunque parezca dificil, es de lo más sencillo. Aún y así lo explicaré línea a línea para su mejor comprensión.

for(n = 0; n < 2; n++){

Un bucle for que usa la variable n y se le suma 1 siempre que sea menor a 2.

printf("\n");

Caracter de nueva línea.

for( i = 0; i < nnotas; i++ ){

Bucle for que usa la variable i y se le suma 1 siempre que sea menor a nnotas.

printf("\nIntroduce la nota numero %d de la persona numero %d: ", i + 1, n + 1);

Un simple printf que indica que puntuación hemos de introducir.

scanf("%f", &puntuacion[n][i]);

Y esta es la línea que (desde mi punto de vista) podría ser más interesante de todo el tutorial. Mediante los dos bucles for de antes, lograremos poder variar todos los valores de puntuación ahorrándonos infinidad de líneas. Normalmente, con un bucle for, en cuanto llega al límite ( en este caso nnotas) se cierra y continúa el programa, pero lo que conseguimos con esto es repetir el bucle tantas veces como queramos ( en este caso 2). Si aún no lo comprendes, vuelve a ver el código que es muy sencillo.

}

Cierra el segundo bucle for.

}

Cierra el primer bucle for.

computarmedia( puntuacion, media, nnotas );

Llamada a la función 'computarmedia'. Y aquí es donde me refería que podría causar confusión varias cosas. En primer lugar (Sólo nos referimos a los arrays), se pasan por referencia pero no hay ningun '&'. Esto es así porque estamos enviando a la función un puntero al primer elemento del array. Una vez pasado un puntero al primer elemento del array, es tan sencillo como que el programa sume i + ( n * t ) siendo i el primer la dirección del primer elemento, n el índice al que se quiere a acceder y t el tipo del array. Por ejemplo, en mi compilador se le asignan 2 bytes a un int. Entonces creo un array 'int array[3]' y la paso a una función escribiendo 'funcion( array )'. Dentro de la función ya tengo un puntero al primer elemento. Ahora, si yo quisiera acceder al tercero, el programa haría array + 3 * 2. Ahora, ¿qué pasa si en vez de escribir eso hubiese escrito 'funcion( array[0] )' ? En es caso, SÍ que lo pasas por valor y no por referencia, ya que no estás pasando un puntero al array, sino el valor del primer elemento.

   scanf("%d", i);
   return 0;
}

La primera línea no sirve para nada más que para parar el programa y ver el resultado. Despues return 0 devuelve 0. Algunos dicen que no es correcto devolver siempre 0, pero yo lo hago de una manera un tanto diferente. } Cierra main.

void computarmedia( float a[1][9], float b[1], int nnotas ){

Definición de la función computarmedia. A diferencia de la declaración de la función, los argumentos tienen que llevar pòr obligación el índice del array.

   int i, n;
 
   for( n = 0; n < 2; n++ ) for( i = 0; i < nnotas; i++ ) b[n] += a[n][i];

Se definen las variables 'i' y 'n' como de tipo int. Despues se crea un bucle similar al de la función main.

   b[0] = b[0] / nnotas;
   b[1] = b[1] / nnotas;

Sentencias para almacenar en b[i] su correspondiente media.

   printf("\nLa puntuacion media de la primera persona es: %.2f", b[0]);
   printf("\nLa puntuacion media de la segunda persona es: %.2f\n", b[1]);

Muestra el resultado de cada persona.

   if( b[0] > b[1] ) printf("\nEl primero ha sacado mejor puntuacion\n\n");
   else printf("\nEl segundo ha sacado mejor puntuacion\n\n");

Comprueba y muestra cual ha sacado mejor puntuación.

   return;
}

Se pone un return y se cierra la función.

Tridimensionales (Multidimensionales)

Para comprender los arrays tridimensionales te conviene pensar en un eje de coordenadas compuesto por x, y, z.

Los arrays tridimensionales serían como una pila de arrays bidimensionales.

La definición de un array multidimensional es muy simple, pero a diferencia de las anteriores, tiene tantos corchetes como dimensiones tenga con un índice cada uno.

tipo nombrearray[índice 1][índice 2]...[índice n];

Se explicarán solo los arrays tridimensionales, el resto se dan por entendido.

Crearemos un programa que calcule la media de las notas de 4 alumnos, dos de cada municipio. Crearemos un array tridimensional de 2x2x10 que almacenará las puntuaciones de cada alumno. El programa pedirá diversos datos y luego se llamará a la función computarmedia, que se encargará del resto:

/*Creado por: P22
Muchisimos agradecimientos a loopin y joserc87
Para: Scenebeta*/
 
#include <stdio.h>
 
int main(){
   //Definiciones
   float puntuacion[2][2][10];
 
   int i, n, j;
   int nnotas = 0;
 
   //Declaración de la función
   void computarmedia( float puntuacion[][][], int nnotas );
 
   printf("Hola! Vamos a calcular la media de notas de dos personas y calcular cual es mejor\n");
 
   //Petición de notas
   printf("En primer lugar: Cuantas notas va a tener cada persona? ");
   scanf("%d", &nnotas);
 
   for( j = 0; j < 2; j++ ){
      for(n = 0; n < 2; n++){
         printf("\n");
         for( i = 0; i < nnotas; i++ ){
            printf("\nIntroduce la nota numero %d de la persona numero %d del grupo numero %d: ", i + 1, n + 1, j + 1);
            scanf("%f", &puntuacion[j][n][i]);
            printf("%f", puntuacion[j][n][i]);
         }
      }
   }
 
   printf("%g", puntuacion[0][0][1]);
 
   computarmedia( puntuacion, nnotas );
 
   system("PAUSE");
   return 0;
}
 
void computarmedia( float a[2][2][10], int nnotas ){
   int i;
   float b[3] = {0, 0, 0, 0};
 
   for( i = 0; i < nnotas; i++ ) b[0] += a[0][0][i];
   for( i = 0; i < nnotas; i++ ) b[1] += a[0][1][i];
   for( i = 0; i < nnotas; i++ ) b[2] += a[1][0][i];
   for( i = 0; i < nnotas; i++ ) b[3] += a[1][1][i];
 
printf("\n%g", a[0][1][1]);
 
   for( i = 0; i < 4; i++ ) b[i] = b[i] / nnotas;
 
   printf("\nLa puntuacion media de la primera persona es: %.2f", b[0]);
   printf("\nLa puntuacion media de la segunda persona es: %.2f", b[1]);
   printf("\nLa puntuacion media de la tercera persona es: %.2f", b[2]);
   printf("\nLa puntuacion media de la cuarta persona es: %.2f", b[3]);
 
   if( b[0] > b[1] ) printf("\nEl primero ha sacado mejor puntuacion\n\n");
   else if( b[1] > b[2] ) printf("\nEl segundo ha sacado mejor puntuacion\n\n");
        else if( b[2] > b[3] ) printf("\nEl tercero ha sacado mejor puntuacion\n\n");
             else printf("\nEl cuarto ha sacado mejor puntuacion\n\n");
   return;
}

Creo que ya deberíamos tener los conocimientos suficientes como para poder analizar solos este ejemplo y comprenderlo, por lo que voy a obviar la explicación.

De momento, esto es todo lo que necesitamos saber sobre arrays, una unidad de almacenamiento muy interesante e importante para la programación. Más adelante veremos otras más complejas y útiles como pueden ser estructuras o uniones.

¡A estudiar! ;-)

Como siempre, agradecería la notificación de cualquier error.