Introducción a la programación

¿Qué es una función? Matemáticamente, una función no es más que una aplicación, esto es, una REGLA o CRITERIO para obtener un cierto resultado a partir de unos valores ya existentes. Este concepto se ha trasladado así al campo de la informática, aunque conviene matizar un poco más la idea.

La idea de función es la de una "caja negra" en la que nosotros metemos datos, dentro de esa "caja" pasa *algo*, y entonces, de la "caja", sale un resultado, un "producto".

Qué pasa dentro de esa "caja negra" depende; si somos nosotros quienes hemos de programarla, lo sabremos, pero si no, no tenemos por qué. Para poder usar la función sólo necesitaremos saber qué datos de entrada admite, y de qué tipo será el resultado. Hay que remarcar un detalle importante: las funciones devuelven un UNICO VALOR.

Por ejemplo; dentro de un programa, podemos querer calcular la media aritmética de una serie de datos. En principio, nosotros lo escribimos cuando tenemos que hacer los cálculos. Pero ahora, resulta que más adelante tenemos que volver a calcular la media aritmética de otros datos. Y más adelante, otra vez. ¿Vamos a escribir el código tantas veces? ¿No sería más lógico definirnos una función que se encargara de esa parte, y llamarla cuando la necesitemos?

Muy bien... ¿y cómo definimos una función? Pues de la siguiente manera:

 funcion NOMBRE (arg1,...,argN) : TIPO
  variables
  ......... {se declaran}
 
      accion1
      .......
      accionN
   Resultado <- Valor
 fin funcion

TIPO es el tipo de dato que devolverá la función al terminar de hacer su trabajo. NOMBRE es el nombre que le vamos a dar a la función; por ejemplo, nuestra función se puede llamar Pepe o se puede llamar Media_Aritmetica. arg1 ... argN es la lista de parámetros que vamos a pasar a la función. La sección "variables" es una sección donde se declararán las variables a usar por la función. Más adelante hablaré del ámbito de las variables, para que se entienda el por qué de esto.

accion1 ... accionN es toda la faena que debe hacer la funcion. Al final de esa faena, la función devuelve un Resultado, que es el que hemos especificado como "Valor". ¿Y a dónde va a parar ese "Valor"? Bueno, es que para poder usar una función, tenemos que *invocarla*, llamarla de alguna manera. Si las funciones son cajas que devuelven valores, tendremos que disponer algún sitio para meter ese valor que nos devuelva la función.

¿Cómo la llamamos?

Para poder llamar a una función, tendremos que tener definida en nuestra declaración de variables una variable del MISMO tipo que devuelva la función. Entonces, lo que hacemos es asignar a esa variable lo que nos devuelva la función, haciendo lo siguiente:

Variable <- Nombre_Funcion(arg1, ..., argN)

Esta línea hace lo siguiente: llama a la función Nombre_Funcion, pasándole los parámetros arg1, ..., argN; entonces, se ejecuta el código de la función, hasta que llega al final, momento en que devuelve un valor, y este valor devuelto es asignado a la variable Variable.

Vamos a ver un ejemplo. Supongamos que queremos hacer un programa que calcule, en varios puntos, la suma de los N primeros números naturales, pero este N varía conforme el programa lo necesita. Queremos hacer una función que nos simplifique el trabajo. ¿Cómo lo hacemos? Bueno, lo primero que hay que plantearse siempre es qué parámetros necesita la función para trabajar, qué tipo de valor va a devolver y, por último, cómo va a hacer lo que tenga que hacer la función.

En nuestro caso, la función sólo necesita saber quién es N, que será de tipo entero; como la suma de naturales es natural, el resultado a devolver también tendrá que ser una variable de tipo entero. Falta ver cómo implementamos esa función. Por ejemplo, lo podemos hacer así (no voy a entrar ahora en mejoras):

 funcion Suma_N_Naturales(ENTERO N) : ENTERO
 variables
  ENTERO: Suma,i
 
  Suma <- 0
  desde i<-1 hasta i=N hacer
        Suma <- Suma+i
 
  Resultado <- Suma
 fin funcion 

y ahora, vamos a usarla. En nuestro programa podemos poner:

 Declaracion variables
  ENTEROS: N, Suma
 fin declaracion variables

 inicio
 
 desde N=1 hasta N=200 hacer
  Suma <- Suma_N_Naturales(N);
  mostrar por pantalla ('La suma de los ',N,' primeros naturales es ',Suma)
 fin desde
 
 fin 

Con esto, hacemos 200 veces, incrementando en 1 cada vez N, la asignación a la variable Suma del resultado obtenido por la función Suma_N_Naturales, y mostrando por pantalla el resultado. Cada vez que se llegue a la línea de la asignación, se llamará a la función Suma_N_Naturales, se ejecutará el código de esa función, y al devolver el resultado, el programa principal recupera el control de la ejecución.

Sin embargo, dentro de la función tenemos declarada una variable que se llama Suma, y en el programa principal hay otra variable que se llama Suma... ¿cómo sabemos cuál es la buena? ¿no se mezclan ni nada parecido los valores?

Bueno, creo que este es un buen momento para hablar de...

. Ámbito de las variables

Como ya hemos visto, un programa no tiene por qué estar formado por un único módulo (vamos a llamarle así) principal, si no que puede estar formado por muchas funciones, y por muchos procedimientos (de los que hablaremos más adelante). Cada función, o cada procedimiento, puede tener, dentro de su sección de declaración de variables, sus propias variables, aunque se llamen igual que las de la función de más arriba, puesto que, al declarar una función o un procedimiento, las variables que usan son LOCALES a ellos, es decir, sólo ellos saben que existen y, por tanto, pueden usarlas.

Como contraposición a las variables locales, tenemos las GLOBALES, que se declaran en una sección VARIABLES GLOBALES; estas variables son reconocidas por cualquier función o procedimiento que exista en nuestro programa, cualquiera puede modificar su valor en cualquier momento.

Ahora, ¿y si hay una variable global que tiene el mismo nombre que una variable local en una función que estoy usando? En ese caso, se usa la variable que es local a la función.

En nuestro ejemplo no se da este conflicto, al no haber una sección de variables globales (eso implica que no las hay), ya que cada variable Suma pertenece a una función distinta.

Algunas notas respecto al tema de funciones:

Es una buena costumbre escribir, justo antes de la definición de la función, un comentario sobre qué hace la función, para qué nos van a servir los parámetros que vamos a pasarle, y qué es lo que devuelve.

Hay que distinguir entre lo que se llama parámetros FORMALES y parámetros ACTUALES.

Cuando definimos una función, en su CABECERA (la línea donde pone su nombre, los argumentos que recibe y el tipo de valor que devuelve) aparecen nombrados los argumentos. El nombre que ponemos en ese momento es lo que se llama parámetros formales. Pero, cuando la llamamos, por ejemplo, Suma_N_Naturales(27), le estamos pasando el parámetro concreto 27: a estos parámetros se les llama parámetros actuales.

Como ejercicio, escribid una función que devuelva el resultado de:

f(x,n)

siendo x un número real y n un número natural.

. Procedimientos

Se llama así a un subprograma que ejecuta unas ciertas acciones sin que valor alguno de retorno esté asociado a su nombre. En otras palabras: NO devuelven valores (en cierto sentido).

Los procedimientos son normalmente llamados desde el algoritmo principal mediante su nombre y una lista de parámetros actuales (como las funciones) a través de una instrucción específica:

LLAMAR (CALL, en inglés)

Se diferencian de las funciones en que los parámetros de llamada pueden ser modificados si así se especifica dentro del procedimiento; en ese sentido se puede interpretar como que devuelven valores.

La forma de declararlos es la siguiente:

 PROCEDIMIENTO Nombre (Lista de parámetros formales)
 variables
 
  acción1
  .......
  acciónN
 Fin Procedimiento 

y la forma de usarlos:

LLAMAR_A Nombre(Lista de parámetros actuales)

Vamos a ver un ejemplo de todo esto: queremos tener una forma de calcular la suma, la resta, el producto y el cociente de dos números cualesquiera. Obviamente, vamos a necesitar 6 variables; 2 de ellas serán los factores, y las otras 4, el resultado de las correspondientes operaciones. Podríamos pensar en 4 funciones que devolvieran cada una de ellas un número (entero, real, ...), pero podemos hacer esto de forma más compacta con un procedimiento. Veamos cómo lo declararíamos:

 PROCEDIMIENTO Cuentas(ENTERO a, ENTERO b, ENTERO sum, ENTERO dif,
                       ENTERO mul, ENTERO dif)
 
  sum <- a+b
  dif <- a-b
  mul <- a*b
  div <- a/b
 
 Fin Procedimiento 

y luego lo podríamos llamar así:

LLAMAR_A Cuentas(5, 3, SUMA, RESTA, MULT, DIV)

con lo que a las variables SUMA, RESTA, MULT, DIV les serían asignados sus correspondientes valores; estas variables se supone que ya están declaradas previamente.

Y llegamos al último punto de esta entrega:

. Recursividad

Una buena definición de este concepto es la siguiente.

Recursivo: ver recursivo

... :-D ... O:-)

Aunque, si lo quereis de otra forma: propiedad de una función o de un subprograma de llamarse a sí mismo.

Ilustremos esto con un ejemplo, nuestra función para sumar los N primeros números naturales. Vamos a escribirla de esta otra forma:

 funcion Suma_N_Naturales(ENTERO N) : ENTERO
 variables
  ENTERO: Suma
 
  si (N=1) entonces
     Suma <- 1
  si no
     Suma <- N+Suma_N_Naturales(N-1)
  fin si
 
  Resultado <- Suma
 fin funcion 

Y vamos a llamarla con Suma_N_Naturales(4), detallando los pasos:


 si (4=1) {falso, no se ejecuta}
 si no {cierto, se ejecuta}
    Suma <- 4+Suma_N_Naturales(4-1) {4-1=3} 

Entramos en Suma_N_Naturales(3):


 si (3=1) {falso, no se ejecuta}
 si no {cierto, se ejecuta}
    Suma <- 3+Suma_N_Naturales(3-1) {3-1=2} 

Entramos en Suma_N_Naturales(2):


 si (2=1) {falso, no se ejecuta}
 si no {cierto, se ejecuta}
    Suma <- 2+Suma_N_Naturales(2-1) {2-1=1} 

Entramos en Suma_N_Naturales(1):

si (1=1) entonces Suma <- 1

y se devuelve el control al punto donde se llamó a Suma_N_Naturales(2), donde tenemos Suma <- 2+1, con lo que se devuelve el control al punto donde se llamó a Suma_N_Naturales(3), teniendo Suma<-3+(2+1), momento en el que se devuelve el control al punto donde se llamó a Suma_N_Naturales(4), donde tenemos Suma <- 4+(3+(2+1)), justo el resultado esperado.

COMPARTE ESTE ARTÍCULO

ENVIAR A UN AMIGO
COMPARTIR EN FACEBOOK
COMPARTIR EN TWITTER
COMPARTIR EN GOOGLE +
SIGUIENTE ARTÍCULO

HAY 2 COMENTARIOS
  • Anónimo dijo:

    Muy pero Muy interesante el articulo, solo que tengo una critica. Explican todo muy bien, pero donde se supone que tenemos que hacer los ejercisios, en que programa!!! en un notepad?? en un Word¡?¡ en un Exel?? en Dreamweaver?, en una hoja?? Aguardo su respuesta!! Gracias.

  • [email protected] dijo:

    En fortran !Ordenacionde vectores por el metodo de la Burbuja Program Ordena_burbuja integer,dimension(100)::x integer::i,j,k,n integer::temp print*,"Ingrese la cantidad de datos al vector" read*,n print*,"Ingrese datos al vector" read*,(x(i),i=1,n) print* !usando el algoritmo de ordenacion por la burbuja Do i=1,n-1 Do j=1,n-1 if (x(j)>x(j+1)) then temp=x(j) x(j)=x(j+1) x(j+1)=temp end if end do end do Print*,"Vector ordenado" Print*,(x(k),k=1,n) end program ordena_burbuja !Ordenacionde vectores por el metodo de seleccion Program Ordena integer,dimension(100)::x integer::i,j,min,n integer::temp print*,"Ingrese la cantidad de datos al vector" read*,n print*,"Ingrese datos al vector" read*,(x(i),i=1,n) print* !usando el algoritmo de ordenacion por seleccion Do i=1,n-1 min=i Do j=i+1,n if (x(j)<x(min)) then min=j end if temp=x(i) x(i)=x(min) x(min)=temp end do end do Print*,"Vector ordenado" Print*,(x(i),i=1,n) end program ordena atte William

Conéctate o Regístrate para dejar tu comentario.