Un array es una colección de variables del mismo tipo que se referencian por un nombre común. A un elemento específico de un array se accede mediante un índice. En C todos los arrays constan de posiciones de memoria contiguas. La dirección más baja corresponde al primer elemento y la más alta al último. Los arrays pueden tener una o varias dimensiones. El array más común en C es la cadena, que simplemente es un array de caracteres terminado por uno nulo.
Arrays unidimensionales :
Los arrays unidimensionales son listas de información del mismo tipo que se guardan en posiciones contiguas de memoria según el orden del índice. La forma general de declaración es:tipo nombre_variable [tamaño];
Los arrays tienen que declararse implícitamente para que el compilador reserve espacio en memoria para ellos. El tipo declara el tipo de los elementos del array, el tamaño indica cuántos elementos mantendrá el array.
Para declarar un array de 10 elementos denominado p y de tipo carácter, se escribe: p y de tipo carácter, se escribe: char p[10];En este caso hemos declarado un array que tiene diez elementos, desde p[0] hasta p[9].
En C todos los arrays tienen el 0 como índice de su primer elemento.
C no comprueba los límites de los arrays. Se puede pasar cualquier extremo de un array y escribir en alguna otra variable de datos e incluso en el código del programa.
Cadenas :
El uso más común de los arrays unidimensionales es como cadenas de caracteres. En C una cadena se define como un array de caracteres que termina en un carácter nulo (¿\0¿).
Para declarar un array de caracteres es necesario un carácter más que la cadena más larga que pueda contener, para dejar sitio para el carácter nulo del final de la cadena.
Una constante de cadena es una lista de caracteres encerrada entre dobles comillas. Por ejemplo: "hola, que tal"
No es necesario añadir explícitamente el carácter nulo al final de las constantes de cadena, el compilador lo hace automáticamente.
Arrays multidimensionales :
C permite arrays de más de una dimensión. La forma general de declaración de un array multidimensional es:
Tipo nombre [a] [b] [c] ¿.. [z];
Los arrays de tres o más dimensiones no se utilizan a menudo por la cantidad de memoria que se requiere para almacenarlos, ya que el almacenamiento requerido aumenta exponencialmente con el número de dimensiones.9.4 Inicialización de arrays C permite la inicialización de arrays en el momento de declararlos, como en cualquier variable. La forma general es: tipo nombre [tamaño1] ¿ [tamaño n]={lista de valores};
la lista de valores es una lista de constantes separadas por comas cuyo tipo es compatible con el tipo especificado en la declaración del array. Por ejemplo: int i[10] = {1,2,3,4,5,6,7,8,9,10};
Con las cadenas o arrays de caracteres se hace igual, aunque permite una inicialización abreviada. Estas dos sentencias producen el mismo resultado:
char cad[11] = "Me gusta C";
char cad[11] = {¿M¿,¿e¿,¿ ¿,¿g¿,¿u¿,¿s¿,¿t¿,¿a¿,¿ ¿,¿C¿,¿\0¿};
Los arrays multidimensionales se inicializan del mismo modo que los unidimensionales.
----------------------------------------------------------------------------------------------------
Los punteros y los arrays tienen una relación muy estrecha en C, ya que el nombre de un array es en realidad un puntero al primer elemento de ese array. Si x es un array undimensional, la dirección del primer elemento puede ser expresada como &x[0] o simplemente como x. La dirección del elemento i-ésimo se puede expresar como &x[i] o como (x+i).
(En este caso, la expresión (x+i) no es una operación aritmética convencional, sino una operación con punteros, de cuyas peculiaridades ya hemos hablado en un epígrafe anterior)
Si &x[i] y (x+i) representan la dirección del i-ésimo elemento de x, podemos decir que x[i] y *(x+i) representan el contenido de esa dirección, es decir, el valor del i-ésimo elemento de x. Observe que la forma x[i] es la que hemos estado utilizando hasta ahora para acceder a los elementos de un vector.
Los arrays, por lo tanto, pueden utilizarse con índices o con punteros. Al programador suele resultarle mucho más cómodo utilizar la forma x[i] para acceder al elemento i-ésimo de un array. Sin embargo, hay que tener en cuenta que la forma *(x+i) es mucho más eficiente que x[i], por lo que suele preferirse cuando la velocidad del ejecución es un factor determinante.
Punteros y arrays multidimensionales
Un array multidimensional es en realidad una colección de varios arrays unidimensionales (vectores). Por tanto, se puede definir un array multidimensional como un puntero a un grupo contiguo de arrays unidimensionales.
El caso más simple de array de varias dimensiones es el bidimiensional. La declaración de un array bidimensional la hemos escrito hasta ahora como:
tipo_dato variable [expresión1][expresión2];
Pero también puede expresarse así:
tipo_dato (*variable) [expresión2];
Los paréntesis que rodean al puntero deben estar presentes para que la sintaxis sea correcta.
Por ejemplo, supongamos que x es un array bidimensional de enteros con 10 filas y 20 columnas. Podemos declarar x como:
int x[10][20];
Y también como:
int (*x)[20];
En la segunda declaración, x se define como un puntero a un grupo de array unidimensionales de 20 elementos enteros. Así x apunta al primero de los arrays de 20 elementos, que es en realidad la primera fila (fila 0) del array bidimensional original. Del mismo modo (x+1) apunta al segundo array de 20 elementos, y así sucesivamente.
Por ejemplo, el elemento de la fila 2 y la columna 5 puede ser accedido así:
x[2][5];
Pero también así:
*(*(x+2)+5);
Esta instrucción parece muy complicada pero es fácil de desentrañar:
- (x+2) es un puntero a la fila 2
- *(x+2) es el objeto de ese puntero y refiere a toda la fila. Como la fila 2 es un array unidimensional, *(x+2) es realmente un puntero al primer elemento de la fila 2.
- (*(x+2)+5) es un puntero al elemento 5 de la fila 2.
- El objeto de este puntero *(*(x+2)+5) refiere al elemento 5 de la fila 2.
Arrays de punteros
Un array multidimensional puede ser expresado como un array de punteros en vez de como un puntero a un grupo contiguo de arrays. En términos generales un array bidimensional puede ser definido como un array unidimensional de punteros escribiendo:
tipo_dato *variable[expresión1];
...en lugar de la definición habitual, que sería:
tipo_dato variable[expresión1][expresión2];
Observe que el nombre del array precedido por un asterisco no está cerrado entre paréntesis. Ese asterisco que precede al nombre de la variable establece que el array contendrá punteros.
Por ejemplo, supongamos que x es un array bidimensional de 10 filas y 25 columnas. Se puede definir x como un array unidimensional de punteros escribiendo:
int *x[25];
Aquí x[0] apunta al primer elemento de la primera columna, x[1] al primer elemento de la segunda columna, y así sucesivamente. Observe que el número de elementos dentro de cada columna no está especificado explícitamente. Un elemento individual del array, tal com x[2][5] puede ser accedido escribiendo:
*(x[2]+5)
En esta expresión, x[2] es un puntero al primer elemento en la fila 2, de modo que (x[2]+5) apunta al elemento 5 de la fila 2. El objeto de este puntero, *(x[2]+5), refiere, por tanto, a x[2][5].
Los arrays de punteros ofrecen un método conveniente para almacenar cadenas. En esta situación cada elemento del array es un puntero que indica dónde empieza cada cadena.
---------------------------------------------------------------------------------------------------------
Más info interesante en ::
http://www.chuidiang.com/chuwiki/index.php?title=Arrays_en_C
¿Quieres tener tu propio blog?
*GRACIAS NELSON! 
