ARREGLOS CON FUNCIONES

Introducción

En C se indica el número de elementos que tiene un arreglo unidimensional

poniendo, después del nombre del arreglo, la dimensión del mismo entre
corchetes: nombre[N], donde N es el número de elementos. El índice del
primer elemento del arreglo es 0 y el último es N-1.
El paso de arreglos a funciones es una de las operaciones más comunes en la
programación. Para que una función pueda recibir un arreglo unidimensional
simplemente se especifica su tipo y se coloca después de su identificador, un par de
corchetes vacíos. Por ejemplo en el siguiente prototipo de función:

float Prom( float x[ ], int n);

El compilador reconoce que el primer argumento que la función va a recibir es un

arreglo por el par de corchetes vacío. El segundo argumento, que es una cantidad
entera, representa el número de elementos del arreglo que será procesado. También
se puede especificar, por ejemplo, si se va a pasar un arreglo de 10 elementos, la
dimensión del arreglo así:

float Prom(float x[10], int n);

pero como no es necesario, rara vez se utiliza.

 EJEMPLO
Para invocar a Prom se coloca el identificador del arreglo como primer parámetro y el número de datos que se
desea procesar como segundo. Por ejemplo, a continuación se define a Prom de modo que regrese el
promedio de una serie de números reales:
float Prom(float x[], int n)
{
int i;
float r = 0;
for(i = 0;i < n; i++)
r += x[i]; /* se suman los elementos*/
return r / n;
}
int main(void)
{
float a[10] = {3.1, 4.6, 8.0, 7.2, 6.9};
float p;
p = Prom(a, 5); /* sólo se desea procesar los 5 primeros elementos del arreglo*/
printf(“%f\n”, p);
return 0;
}
Cuando se pasa en arreglo a una función se está proporcionando a la función la dirección de comienzo
asignada al arreglo, por lo que la función que recibe el arreglo, puede escribir o manipular la información
contenida en el mismo. En otras palabras, en realidad no se pasa el arreglo a la función, y toda la carga
que esto representa, sobre todo tratándose de arreglos de tamaños considerables, sino la dirección en
donde éste comienza. En el siguiente programa de ejemplo, presenta a una función que recibe un arreglo
y el número de datos que se desea procesar, y lo ordena de forma ascendente, mediante el método
conocido como “método de la burbuja”
/*Ejemplo 1: Método de la burbuja*/
#include <stdio.h>
#include <conio.h>
/*Función que recibe un arreglo y lo ordena de forma ascendente por el método de la
burbuja*/
void Ordena(float Arreglo[], int Tam)
{
int i,j;
float t;
for(i=1; i<Tam; ++i)
for(j=Tam-1; j>=i; --j)
if(Arreglo[j-1]>Arreglo[j])
{
t=Arreglo[j-1];
Arreglo[j-1]=Arreglo[j];
Arreglo[j]=t;
}
}
/* Función que guarda los datos en un arreglo,y posteriormente lo envía a otra función que los ordena*
void GuardaArreglo()
{
int i, Tam;
float Arreglo[100];
printf("DAR EL NUMERO DE DATOS QUE SE QUIERE PROCESAR \n");
scanf("%d", &Tam);
if(Tam>100)
printf("EL NÚMERO QUE DISTE EXCEDE AL TAMAÑO DEL ARREGLO \n");
else
{
printf("DAR LOS ELEMENTOS DEL ARREGLO \n");
for(i=0; i<Tam; i++)
{
printf("Arreglo[%d]= ", i);
scanf("%f", &Arreglo[i]);
}
Ordena(Arreglo, Tam); /*llamada a la función Ordena con el envío del arreglo y
el numero de datos a procesar */
printf("\n LOS NÚMEROS ORDENADOS SON \n");
for(i=0; i<Tam; i++)
printf("%.2f \t", Arreglo[i]);
return 0;
}
}
int main(void)
{
GuardaArreglo(); /* Se llama a la función que guarda datos en el arreglo*/
return 0;
}
Ejemplo 2. Número capicúa

Se desea leer por teclado un número entero largo e indicar si el número leído
es o no capicúa.
Para esto, se debe considerar que un número capicúa es aquél que es leído
igual de izquierda a derecha que de derecha a izquierda por ejemplo 15651.
Es indispensable, como primer paso, saber la cantidad (k) de dígitos que el
número ingresado contiene, cuáles son estos dígitos y la posición que ocupan
dentro del número –contabilizar la posición a partir de cero y finalizando
en cantidad de dígitos menos uno (k-1).
 En el número 15615 se tienen 6 dígitos y las posiciones de cada uno son:

El segundo paso consiste en comparar de dos en dos los dígitos del número, iniciando en los extremos y
finalizando en el centro, esto es, la primera comparación se realiza entre el primer dígito y el dígito k-1, la
segunda comparación es entre el segundo dígito y el dígito k-2, así sucesivamente.
Observar que un número con una cantidad de dígitos impar, no necesita comparar el
dígito central con otro dígito.
Considerando los pasos anteriores, se plantean en el programa dos funciones:

a) int numero(long c,int tabla[]) - la cual permite realizar la cuenta de la cantidad

de dígitos contenidos en el número y guardar uno por uno en un arreglo.

b) int comparar_numero(int c,int tabla[]) – ésta permite realizar las comparaciones

por parejas de los dígitos contenidos en el número, para resolver si éste es o no capicúa.
/*Ejemplo 2: Programa que indica si un número entero es o no capicúa*/
#include <stdio.h>
int numero(long a,int tabla[]);
int comparar_numero(int c,int tabla[]);
int main(void)
{
long n;
int t[50], c;
printf("\nIntroduce un número para ver si es capicúa :");
scanf("%ld",&n);
c=numero(n,t);
if(comparar_numero(c,t))
printf("\nEl número es capicúa \n ");
else
printf("\nEl número no es capicúa\n");
}
int numero(long a,int tabla[]) /*Función que cuenta la cantidad de dígitos en el número*/
{
int cifras=0;
while(a!=0)
{
tabla[cifras]=a%10;
a=a/10;
cifras++;
}
return cifras; /*Cantidad de dígitos */
}
int comparar_numero(int c,int tabla[]) /*Función que compara los dígitos*/
{
int i=0;
while(i<c)
{
if(tabla[i]!=tabla[c-1])
return 0; /*El número no es capicúa*/
i++;
c--;
}
return 1; /*El número es capicúa*/
}
 Errores comunes

• Omitir el tipo de valor de regreso definido para una función en la declaración del
prototipo, olvidando escribir un valor de retorno.

• Regresar un valor de una función que fue declarada como void.

• Volver a definir dentro de la función una variable como local, siendo que ésta fue
declarada como variable paramétrica dentro de los paréntesis de la función.