Arreglos Unidimensionales Y Multidimensionales
Enviado por JLHC • 12 de Agosto de 2013 • 1.621 Palabras (7 Páginas) • 381 Visitas
Arreglos unidimensionales y multidimensionales
Los arreglos son una colección de variables del mismo tipo que se referencian
utilizando un nombre común. Un arreglo consta de posiciones de memoria
contigua. La dirección más baja corresponde al primer elemento y la más alta al
último. Un arreglo puede tener una o varias dimensiones. Para acceder a un
elemento en particular de un arreglo se usa un índice. El formato para declarar
un arreglo unidimensional es:
tipo nombre_arr [ tamaño ]
Por ejemplo, para declarar un arreglo de enteros llamado a con diez elementos
se hace de la siguiente forma:
int a[10];
En C, todos los arreglos usan cero como índice para el primer elemento. Por
tanto, el ejemplo anterior declara un arreglo de enteros con diez elementos
desde a[0] hasta a[9].
La forma como pueden ser accesados los elementos de un arreglo, es de la
siguiente forma:
a[2] = 15; /* Asigna 15 al 3er elemento del arreglo a*/
num = a[2]; /* Asigna el contenido del 3er elemento a la variable num */
El lenguaje C no realiza comprobación de contornos en los arreglos. En el caso de
que sobrepase el final durante una operación de asignación, entonces se
asignarán valores a otra variable o a un trozo del código, esto es, si se
dimensiona un arreglo de tamaño N, se puede referenciar el arreglo por encima
de N sin provocar ningún mensaje de error en tiempo de compilación o
ejecución, incluso aunque probablemente se provoque un error en el programa.
Como programador se es responsable de asegurar que todos los arreglos sean lo
suficientemente grandes para guardar lo que pondrá en ellos el programa.
C permite arreglos con más de una dimensión, el formato general es:
tipo nombre_arr [ tam1 ][ tam2 ] ... [ tamN];
Por ejemplo un arreglo de enteros bidimensionales se escribirá como:
int b[50][50];
Observar que para declarar cada dimensión lleva sus propios paréntesis
cuadrados.
Para acceder los elementos se procede de forma similar al ejemplo del arreglo
unidimensional, esto es,
b[2][3] = 15; /* Asigna 15 al elemento de la 3ª fila y la 4ª columna*/
num = b[25][16];
A continuación se muestra un ejemplo que asigna al primer elemento de un
arreglo bidimensional cero, al siguiente 1, y así sucesivamente.
main() {
int t,i,num[3][4];
for(t=0; t<3; ++t)
for(i=0; i<4; ++i)
num[t][i]=(t*4)+i*1;
for(t=0; t<3; ++t){
for(i=0; i<4; ++i)
printf("num[%d][%d]=%d ", t,i,num[t][i]);
printf("\n");
}
}
En C se permite la inicialización de arreglos, debiendo seguir el siguiente
formato:
tipo nombre_arr[ tam1 ][ tam2 ] ... [ tamN] = {lista-valores};
Por ejemplo:
int c[10] = {1,2,3,4,5,6,7,8,9,10};
int num[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
Tipo FILE:
C define la estructura de datos FILE en el archivo de cabecera "stdio.h"
para el manejo de archivos. Nosotros siempre usaremos punteros a estas
estructuras.
La definición de ésta estructura depende del compilador, pero en general
mantienen un campo con la posición actual de lectura/escritura, un buffer
para mejorar las prestaciones de acceso al archivo y algunos campos para
uso interno.
Función fopen:
Sintaxis:
FILE *fopen(char *nombre, char *modo);
ésta función sirve para abrir y crear archivos en disco. El valor de retorno es
un puntero a una estructura FILE. Los parámetros de entrada son:
nombre: una cadena que contiene un nombre de archivo válido, esto
depende del sistema operativo que estemos usando. El nombre puede
incluir el camino completo.
modo: especifica en tipo de archivo que se abrirá o se creará y el tipo de
datos que puede contener, de texto o binarios:
r: sólo lectura. El archivo debe existir.
w: se abre para escritura, se crea un archivo nuevo o se sobrescribe si ya
existe.
a: añadir, se abre para escritura, el cursor se sitúa al final del archivo. Si el
archivo no existe, se crea.
r+: lectura y escritura. El archivo debe existir.
w+: lectura y escritura, se crea un archivo nuevo o se sobrescribe si ya
existe.
a+:
...