III.

Arreglos

3.1 Definición de Arreglos

Un arreglo es un conjunto de elementos con iguales características (tipo de dato),
compartiendo el mismo nombre y estos son identificados con un índice. Los elementos
de un arreglo permiten almacenar datos temporalmente.
Existen diferentes tipos de arreglos, tales como los de una dimensión, dos dimensiones
y n cantidad de dimensiones.

3.2 Arreglos unidimensionales

Hacen referencia a una sola dirección o posición.

Su representación gráfica es la siguiente:

x[0] x[1] x[2] x[3] x[4]

x es el nombre del arreglo 0 es el primer índice (que indica la posición que ocupa el
elemento dentro del arreglo)
3.2.1 Declaración de un arreglo unidimensional
Para definir un arreglo de una dimensión se utiliza el siguiente formato.

Formato:

tipo_almacenamiento tipo_dato nombre_arreglo [ expresión]= {valor1... valorn};

tipo_almacenamiento = Se refiere al tiempo y vida de la variable, es la poción del

programa en la cual se reconoce la variable en el
programa.
Esta puede ser por:
 Es opcional. Entonces se toma en cuenta la localización de su declaración
en el programa:
Los valores por defecto son automáticos para arreglos definidos dentro de una función o
bloque, extern para arreglos definidos fuera de una función y estáticos para arreglos de
data fija.

 Por la clave:
auto: son locales a la función o bloque.
extern: para arreglos definidos fuera de la función
static: su valor se mantiene o conserva, si se modifica el arreglo en una función y se
vuelve a llamar la función , el arreglo mantiene según sus últimas modificaciones..

tipo_dato=el tipo de dato para los elementos del arreglo, puede ser float, char,
etc.

nombre_arreglo= es el nombre del arreglo.

expresión= la expresión debe ser positiva que indica el número de elementos.

O una constante simbólica declarada con
valor1, ...valorn= Es opcional y sólo se especifica en caso de que desee
inicializar un arreglo. Representan los contenidos de los
elementos, desde la posición 0 hasta la posición n.

Al inicializar arreglos, los arreglos automáticos, a diferencia de las variables

automáticas, no pueden ser inicializados (depende del compilador). Sin
embargo, las definiciones de arreglos estáticos y externos pueden incluir, si se
desea, la asignación de valores iniciales.
Un arreglo de una dimensión o conocido también como vector puede
tomar valores por:

 Inicialización
 Por asignación
 Por lectura

Ejemplo por Inicialización Descripción

#include <stdio.h>
main( )
{

static int z[4]= {5,6,7,9}; Se utiliza cuando se conocen los datos

z[0] 5
z[1] 6
z[2] 7
z[3] 9

static float m[3]={2.3,2.5};

Los últimos valores que no se les

2.3 asigne valor se le inicializan en:
m[1] 0 si son int
2.5
m[2] 0.0 si son float o double
0.0

Ejemplo por asignación Descripción

#include <stdio.h>
main( ) Se necesita cargar el vector con todos
{ int z[6]; sus elementos con el valor de 7
int i;
for (i=0; i<6; i++)
z[i]= 7;

Ejemplo por lectura Descripción

#define n 4
#include <stdio.h>
main( ) Se necesita cargar el vector con
{ int x[5]; diferentes valores para sus elementos
int i;
for (i=0; i<5; i++)
{ printf (“Entre un elemento”);
scanf (“%i”, &x[i]);
}

2 4 500 7 67

x[0] x[1] x[2] x[3] x[4]

#define nombre_constante valor

float y[n];
for (i=0; i<n; i++)
{ printf (“Entre un elemento”);
scanf (“%i”, &y[i]);
}
La presencia de la expresión, que
indica el número de elementos del
arreglo, es opcional cuando los valores
iniciales están presentes.
 y[0] y[1] y[2] y[3]

3.3.3 Procesamiento de un arreglo de una dimensión.

En C no se permite operaciones que impliquen arreglos completos. Las operaciones de
asignación, de comparación, etc. Deben realizarse elemento por elemento, variando el
índice con ciclos de repetición.

Si se va a leer un elemento hay que colocarle por delante el símbolo de &.

Ejemplos:

int x[4]; int x[4];

int i; int i;
. .
. .
. .
printf (“\nEntre los 4 elementos del vector”); for (i=0; i<4; i++)
for (i=0; i<4; i++) {printf (“\nEntre un elemento del vector”);
scanf (“%i”,&x[i]); scanf (“%i”,&x[i]);
}

int x[4];
int i;
.
.
.
for (i=0; i<=3; i++)
{ printf (“\nEntre el elemento numero %i”, i+1);
scanf (“%i”,&x[i]);
}
Para accesar un elemento de un arreglo de una dimensión se utiliza el siguiente formato.

Formato:

nombre_arreglo [índice]

Ejemplo:

for (i=0; i<4; i++)

if (x[i] == 576)
________________ ;
________________ ;

Paso de un arreglo de una dimensión a una función.

Todo nombre de arreglo contiene la dirección inicial de memoria donde se almacenó el
arreglo.

Ejemplo:
int x [ 4 ]; El compilador asigna la dirección inicial donde se almacenará el
arreglo

El nombre de un arreglo se puede usar como argumento de una función, permitiendo así
que el arreglo completo sea pasado a la función. Los argumentos pasados de ésta
manera se dice que son pasados por referencia en vez de por valor.

Un sólo elemento del arreglo al pasarlo a una función, pasará por valor.

Al utilizar la función return para retornar un elemento, lo que regresa por valor.

Paso por valor es cuando pasamos una variable a una función y si se realizan cambios
en ella, al regresar al punto después del llamado, el valor de la misma se mantiene con
el valor original.

Paso por referencia es cuando pasamos una dirección de memoria.

Como todo nombre de arreglo contiene la dirección inicial de memoria donde se
empezó almacenar el primer elemento del arreglo, entonces si pasamos el nombre del
arreglo se está pasando la dirección de memoria donde se encuentra almacenado el
primer elemento del arreglo, por lo que nos podríamos desplazar o accesar todos los
elementos del arreglo. Es por esto que si se realizaran cambios en el arreglo, al regresar
al punto después del llamado, el contenido de los elementos mantiene los últimos
cambios realizados en la función.
Un nombre de un arreglo es una variable por referencia como si fuera un puntero.
Ejemplo:

#include <stdio.h>
#include <conio.h>
main( )
{
int a;
float tab[100]; //definición del arreglo de una dimensión
float v;

float proceso (int a, float tab[ ], float tab[2]); //función prototipo

v= proceso (a, tab, tab[2]); // llamado de la función

Parámetros actuales (o emisores)

a es una variable, el paso es por valor
tab es el arreglo, el paso es por referencia
tab[2] es el elemento de la posición 2 del arreglo,
} el paso es por valor
v almacena el valor del elemento de la posición 7
que es retornado

float proceso (int af, float tabf[ ], float elemento ) //definición de la función
{ float x[8];
Parámetros formales o receptores (los nombres de los parámetros formales
return (x[2]); pueden ser iguales a los nombres de los parámetros actuales)
} af es una variable que recibe el valor de la variable a
tabf es el nombre de un arreglo que recibe la dirección de memoria
del arreglo tab
elemento es una variable que recibe el valor del elemento tab[2]
Para recordar, una función puede retornar un valor o nada.

En caso que se retorne un elemento lo que se retorna es el valor.

En caso que se necesite retornar un arreglo, se debe especificar es el nombre del arreglo.
Entonces lo que se retorna es la dirección de memoria. Pero hay que tener presente es
que la declaración de variables local a una función son liberadas una vez se retorne. Y si
se declaró un arreglo local a la función cuando se retorne el espacio que ocupa el arreglo
es liberado. Para no perder los valores almacenados se puede utilizar la palabra
reservada static para el tipo de almacenamiento.

Ejemplo:
char * proceso ( )
{ static float w[ 5 ];
. . .
return w;
}