PDF de programación - 5 Arreglos

5

Arreglos

Los arreglos (arrays) permiten almacenar vectores y matrices. Los arreglos unidimensionales
sirven para manejar vectores y los arreglos bidimensionales para matrices. Sin embargo, las ma-
trices también se pueden almacenar mediante arreglos unidimensionales y por medio de apuntadores a
apuntadores, temas que se verán en el capítulo siguiente.

La palabra unidimensional no indica que se trata de vectores en espacios de dimensión uno; indica
que su manejo se hace mediante un subíndice. El manejo de los arreglos bidimensionales se hace mediante
dos subíndices.

5.1 Arreglos unidimensionales

El siguiente ejemplo muestra la definición de tres arreglos, uno de 80 elementos doble precisión, otro

de 30 elementos enteros y uno de 20 elementos tipo carácter.

double x[80];
int factores[30];
char codSexo[20];

Los nombres deben cumplir con las normas para los identificadores. La primera línea indica que se han
reservado 80 posiciones para números doble precisión. Estas posiciones son contiguas. Es importante
recalcar que en C, a diferencia de otros lenguajes, el primer elemento es x[0], el segundo es x[1], el
tercero es x[2], y así sucesivamente; el último elemento es x[79].

En x hay espacio reservado para 80 elementos, pero esto no obliga a trabajar con los 80; el programa

puede utilizar menos de 80 elementos.

C no controla si los subíndices están fuera del rango previsto; esto es responsabilidad del programador.
Por ejemplo, si en algún momento el programa debe utilizar x[90], lo usa sin importar si los resultados
son catastróficos.

Cuando un parámetro de una función es un arreglo, se considera implícitamente que es un parámetro
por referencia. O sea, si en la función se modifica algún elemento del arreglo, entonces se modificó real-
mente el valor original y no una copia. Pasar un arreglo como parámetro de una función y llamar esta
función es muy sencillo. Se hace como en el esquema siguiente.

... funcion(..., double x[], ...); // prototipo
//------------------------------------------------
int main(void)
{

double v[30];
...
... funcion(..., v, ...); // llamado a la funcion

59

5. ARREGLOS

...

}
//------------------------------------------------
... funcion(..., double x[],...)// definicion de la funcion
{

// cuerpo de la funcion
...

}

En el esquema anterior, el llamado a la función se hizo desde la función main. Esto no es ninguna
obligación; el llamado se puede hacer desde cualquier función donde se define un arreglo o donde a su
vez llega un arreglo como parámetro.

También se puede hacer el paso de un arreglo como parámetro de la siguiente manera. Es la forma

más usual. Tiene involucrada la noción de apuntador que se verá en el siguiente capítulo.

... funcion(..., double *x, ...); // prototipo
//------------------------------------------------
int main(void)
{

double v[30];
...
... funcion(..., v, ...); // llamado a la funcion
...

}
//------------------------------------------------
... funcion(..., double *x, ...)// definicion de la funcion
{

// cuerpo de la funcion
...

}

El programa del siguiente ejemplo lee el tamaño de un vector, lee los elementos del vector, los escribe y
halla el promedio. Para esto utiliza funciones. Observe la manera como un arreglo se pasa como parámetro.

// Arreglos unidimensionales
// Lectura y escritura de un vector y calculo del promedio
//------------------------------------------------
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
//------------------------------------------------
void lectX(double *x, int n, char c );
void escrX(double *x, int n );
double promX( double *x, int n);
//================================================
int main()
{

double v[40];
int n;

printf("\n Promedio de elementos de un vector.\n\n");

60

5.1. ARREGLOS UNIDIMENSIONALES

printf(" numero de elementos : ");
scanf( "%d", &n);
if( n > 40 ){

printf("\n Numero demasiado grande\n\n");
exit(1);

}
lectX(v, n, ’v’);
printf(" v : \n");
escrX(v, n);
printf(" promedio = %lf\n", promX(v, n));
return 0;

}
//================================================
void lectX(double *x, int n, char c )
{

// lectura de los elementos de un "vector".

int i;

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

printf(" %c(%d) = ", c, i+1);
scanf("%lf", &x[i] );

}

}
//------------------------------------------------
void escrX(double *x, int n )
{

// escritura de los elementos de un "vector".

int i;
int nEltosLin = 5; // numero de elementos por linea

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

printf("%15.8lf", x[i]);
if( (i+1)%nEltosLin == 0 || i == n-1) printf("\n");

}

}
//------------------------------------------------
double promX( double *x, int n)
{

// promedio de los elementos del ’vector’

x

int i;
double s = 0.0;

if( n <= 0 ){

printf(" promX: n = %d inadecuado\n", n);
return 0.0;

}
for( i = 0; i < n; i++) s += x[i];
return s/n;

}

61

La función lectX tiene tres parámetros: el arreglo, el número de elementos y una letra. Esta letra sirve
para el pequeño aviso que sale antes de la lectura de cada elemento. En el ejemplo, cuando se “llama” la
función, el tercer parámetro es ’v’; entonces en la ejecución aparecerán los avisos:

5. ARREGLOS

v(1) =
v(2) =
...

Observe que en el printf de la función lectX aparece i+1; entonces para el usuario el “vector” empieza
en 1 y acaba en n. Internamente empieza en 0 y acaba en n − 1.

Es importante anotar que si durante la entrada de datos hay errores, es necesario volver a empezar
para corregir. Suponga que n = 50, que el usuario ha entrado correctamente 40 datos, que en el dato
cuadragésimo primero el usuario digitó mal algo y después oprimió la tecla Enter. Ya no puede corregir.
Sólo le queda acabar de entrar datos o abortar el programa (parada forzada del programa desde el sistema
operativo) y volver a empezar. Esto sugiere que es más seguro hacer que el programa lea los datos en un
archivo. La entrada y salida con archivos se verá en un capítulo posterior.

Cuando un arreglo unidimensional es parámetro de una función, no importa que el arreglo haya sido
declarado de 1000 elementos y se trabaje con 20 o que haya sido declarado de 10 y se trabaje con 10. La
función es de uso general siempre y cuando se controle que no va a ser llamada para usarla con subíndices
mayores que los previstos. En la siguiente sección se trata el tema de los arreglos bidimensionales. Allí,
el paso de parámetros no permite que la función sea completamente general.

En el siguiente ejemplo, dado un entero n ≥ 2 (pero no demasiado grande), el programa imprime los
factores primos. El algoritmo es muy sencillo. Se busca d > 1, el divisor más pequeño de n. Este divisor
es necesariamente un primo. Se divide n por d y se continúa el proceso con el último cociente. El proceso
termina cuando el cociente es 1. Si n = 45, el primer divisor es 3. El cociente es 15. El primer divisor de
15 es 3. El cociente es 5. El primer divisor de 5 es 5 y el cociente es 1.

// Arreglos unidimensionales
// Factores primos de un entero >= 2
//------------------------------------------------
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
//------------------------------------------------
int primerDiv( int n);
int factoresPrimos( int n, int *fp, int &nf, int nfMax);
//================================================
int main()
{

int vFactPrim[40]; // vector con los factores primos
int n;
int nFact;
int i;

// numero de factore primos

printf("\n Factores primos de un entero >= 2.\n\n");

printf(" n = ");
scanf( "%d", &n);
if( factoresPrimos(n, vFactPrim, nFact, 40) ){

for(i = 0; i < nFact; i++) printf(" %d",

vFactPrim[i]);

printf("\n");

62

5.1. ARREGLOS UNIDIMENSIONALES

}
else printf(" ERROR\n");
return 0;

}
//================================================
int primerDiv( int n)
{

debe ser mayor o igual a 2.

// n
// Calcula el primer divisor, mayor que 1, de
// Si n
// Si hay error, devuelve

0.

es primo, devuelve

n.

n

int i;

if( n < 2 ){

printf(" primerDiv: %d inadecuado.\n", n);
return 0;

}
for( i = 2; i*i <= n; i++) if( n%i == 0 ) return i;
return n;

}
//================================================
int factoresPrimos( int n, int *fp, int &nf, int nfMax)
{

// factores primos de n
// devuelve 0
// devuelve 1
// fp :
// nf :
// nfMax : tamano del vector

si hay error.
si todo esta bien.

vector con los factores primos
numero de factores primos

fp

int d, indic;

if( n < 2 ){

printf(" factoresPrimos: %d inadecuado.\n", n);
return 0;

}
nf = 0;
do{

if( nf >= nfMax ){

printf("factoresPrimos: demasiados factores.\n");
return 0;

}
d = primerDiv(n);
fp[nf] = d;
nf++;
n /= d;

} while( n > 1);
return 1;

}

63

5.2 Arreglos multidimensionales

La declaración de los arreglos bidimensionales, caso particular de los arreglos multidimensionales, se

5. ARREGLOS

hace como en el siguiente ejemplo:

double a[3][4];
int pos[10][40];
char list[25][25];

En la primera línea se reserva espacio para 3 × 4 = 12 elementos doble precisión. El primer subíndice
varía entre 0 y 2, y el segundo varía entre 0 y 3. Usualmente, de manera análoga a las matrices, se dice
que el primer subíndice indica la fila y el segundo subíndice indica la columna.
Un arreglo tridimensional se declararía así:

double c[20][30][10];

Los sitios para los elementos de a están contiguos en el orden fila por fila, o sea, a[0][0], a[0][1],
a[0][2], a[0][3], a[1][0], a[1][1], a[1][2], a[1][3], a[2][0], a[2][1], a[2][2], a[2][3].

En el siguiente ejemplo, el programa sirve para leer matrices, escribirlas y calcular el producto. Lo

hace mediante la utilización de funciones que tienen como parámetros arreglos bidimensionales.

// prog14
// Arreglos bidimensionales
// Lectura y escritura de 2 matrices y calculo del producto
//------------------------------------------------
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
//------------------------------------------------
void lectA0(double a[][40], int m, int n, char c );
void escrA0(doubl