Wiki CC3301

En realidad C no posee verdaderos arreglos como ocurre en Java. En C un arreglo de n elementos de un tipo T corresponde a un puntero al comienzo de un área de memoria que contiene n variables consecutivas de tipo T. De modo que lo que se vió en el capítulo sobre punteros es el 90% de lo que se puede escribir sobre arreglos.

El otro 10% corresponde la declaración de arreglos de tamaño constante. La idea con estos arreglos es evitar tener que llamar a malloc para ubicarlos en el heap. El espacio en memoria se asigna ya sea en el área de variables globales, la pila o el heap según el contexto en que se declaran.

Estos se declaran fuera de toda función como las variables globales:

  double a[100];
  int b[4]= {1, 2, 4, 8};
  short c[]= {10, 20, 30};
  char s[]= {'h', 'o', 'l', 'a', 0};
  int main() {
    int i;
    a[0]= 0;
    a[1]= 1;
    for (i= 2; i<100; i++)
      a[i]= a[i-1] + a[i-2];
  }

El primero es un arreglo de 100 elementos inicializados por omisión en 0. El tipo de la expresión a es double* y corresponde a la dirección del primer elemento de un área de memoria global con espacio para 100 variables consecutivas de tipo double. Su tiempo de vida y alcance es el mismo de todas las variables globales, es decir su memoria se asigna al iniciarse el proceso y solo se libera al terminar el proceso. No se le asigna espacio con malloc. Se accede a sus elementos con la notación p[i] o bien *(p+i). Es decir es equivalente escribir *(a+i)= *(a-i-1) + *(a-i-2);.

En este caso a no es una variable. Es un error asignar una nueva dirección a a como en:

a= (double*)malloc(100*sizeof(double)); /* Esto es un error */

En este caso el identificador a representa una constante con la dirección del primer elemento del arreglo en memoria y por eso el compilador reclama porque no se puede cambiar una constante. Esto queda representado en la siguiente figura:

El arreglo b corresponde a un arreglo de 4 elementos preinicializados con constantes conocidas en tiempo de compilación. El arreglo c también es un arreglo preinicializado solo que el compilador infiere el tamaño del arreglo contando la cantidad de elementos que aparecen en las llaves, en este caso 3. Por último el arreglo s corresponde al mismo caso que c. En la próxima sección veremos que s es en realidad un string.

También es posible declarar un arreglo local a una función. El tiempo de vida y alcance es el mismo de todas las variables automáticas. Por ejemplo:

int f(int *p) {
  int a[20], i, s= 0;
  for (i= 0; i<20; i++)
    a[i]= p[i];
  ordenar(a, 20);
  for (i= 1; i<20; i++)
    s+= a[i]-a[i-1];
}