Temas:

• Definición de funciones.
• Invocación de una función.
• Qué es un procedimiento.
• Definición de un procedimiento.
• Procedimientos con efectos laterales.
• Funciones con efectos laterales.
• Funciones que retornan arreglos.
• Término anticipado de una función.

Motivación

Escribir un programa que determine la cantidad de combinaciones que se pueden realizar tomando k elementos distintos de un grupo de n elementos. El número de combinaciones está dado por la siguiente fórmula:

    | n |      n!
    |   | = ---------
    | k |   k! (n-k)!

• Calcular n!
• Calcular k!
• Calcular (n-k)!
• Entregar resultado final

Definición de funciones

Por esta razón, prácticamente todos los lenguajes incorporan algún mecanismo para que los programadores puedan definir sus propias funciones cuando no existe la función predefinida apropiada. Para definir una nueva función, el programador debe escribir el código (programa) que calcula esa función.

Por ejemplo, el siguiente programa calcula el número de combinaciones:

    class Combinaciones extends Program {
      void run() {
        print("Ingrese k ? ");
        int k= readInt();
        print("Ingrese n ? ");
        int n= readInt();
        int combinaciones= fact(n)/(fact(k)*fact(n-k));
        println("Combinaciones= "+combinaciones);
      }
      // Definición de la funcion fact
      int fact(int x) {
        // fact recibe un argumento entero y entrega un resultado entero.
        // El siguiente código calcula el factorial de x
        int prod= 1;
        int i= 1;
        while (i<=x) {
          prod= prod*i;
          i= i+1;
        }
        // Indica qué valor entrega esta función.
        return prod;
      }
    }

El siguiente patrón de programación se usa para definir varias funciones que pueden ser usadas en un programa:

    class ... extends Program {
      void run() {
        ...
      }
      tipo nombre-función ( parámetros ) {
        ... programa que calcula esta función ...
        return expresión;
      }
      ... Más funciones ...
    }

• tipo: es el tipo del valor entregado por la función. Por ejemplo, el factorial entrega un número entero. Otra función podría entregar un número real o un string.

• nombre-función: es un identificador que elige el programador para nombrar su función.

• parámetros: son los parámetros de la función, es decir de qué depende el cálculo de la función. Pueden indicarse 0, 1, 2 o todos los parámetros que se necesiten.

• return expresión: señala cual es la expresión que representa el valor entregado por la función.

• Una función que no retorna ningún valor se define indicando que entrega un valor de tipo void. En este caso se prefiere hablar de procedimiento.

• void run() { ... }: es un procedimiento que no recibe argumentos y que es invocado por java Run ...

Invocación de una función

    nombre-función ( argumentos )

    fact(n-k)

• Se evalúan las expresiones, obteniendo así valores que corresponden a los argumentos de la función. Por ejemplo, n-k puede dar como resultado 5.

• Se asignan los argumentos a las variables que representan los parámetros en la difinición de la función. Por ejemplo, en la función fact:

      x= 5;
  

• Se ejecutan las instrucciones señaladas en la definición de la función. Es decir:

          int prod= 1;
          int i= 1;
          while (i<=x) {
            prod= prod*i;
            i= i+1;
          }
  

  Después de ejecutar este código, la variable prod almacena el valor 120 (5!) e i el valor 6.

• Se evalúa la expresión que acompaña return.

          return prod;
  

  Como esta expresión es simplemente la variable prod, el resultado de la evaluación es 120. Este valor es el resultado de la invocación de fact y substituye toda la expresión de invocación:

      fact(n-k)
  

En cada invocación el argumento es distinto y por tanto el valor entregado por la función.

Ejercicio 1:

Definir la función repite(s,n) que entrega el string s concatenado con sí mismo n veces. Es decir, se desea que repite("hola",3) entregue (o retorne) como resultado el string "holaholahola".

    class Triangulo extends Program {
      String repite(String s, int n) {
        String r= "";
        int i= 1;
        while (i<=n) {
          r= r+s;
          i= i+1;
        }
        return r;
      }
      void run() {
        int i=1;
        while (i<=8) {
          println(repite("*",i));
          i= i+1;
        }
      }
    }

    *
    **
    ***
    ****
    *****
    ******
    *******
    ********

Ejercicio 2:

Defina la función esPrimo(n) que entrega verdadero cuando n es un número primo y falso en caso contrario. Utilice cualquier método para determinar si n es primo. Ejemplos:

Ejercicio 3:

Escriba un programa que use la función esPrimo para mostrar los números primos entre 200 y 300.

Ejercicio 4:

Defina una función mayor que calcule el máximo valor en un arreglo nativo. Por ejemplo, si el arreglo tab contiene las siguientes asociaciones:

entonces:

    println( mayor(tab, 0, 3) ); // despliega 15.0
    println( mayor(tab, 2, 3) ); // despliega 4.3

Solución:

    double mayor(double[] tab, int pri, int ult) {
      int i= pri;
      double max= tab[pri];
      while (i<=ult) {
        if (tab[i]>max)
          max= tab[i];
        i= i+1;
      }
      return max;
    }

Qué es un procedimiento

    println( ... );

    x= println( ... );

Definición de procedimiento

    void mostrar(double[] tab, int pri, int ult) {
      int i= pri;
      while (i<=ult) {
        println(i+" -> "+tab[i]);
        i= i+1;
      }
      // no hay return
    }

    mostrar(tab, 0, 3);

    0 -> 4.5
    1 -> 15.0
    2 -> 2.2
    3 -> 4.3

Defina el procedimiento grabar que reciba como argumentos un arreglo con valores de tipo double, dos enteros que señalan el rango de llaves válidas (pri y ult) y el nombre de un archivo. Su procedimiento debe producir un archivo con el contenido del arreglo. Por ejemplo, la siguiente invocación:

    grabar(tab, 0, 3, "cont.txt");

    4.5
    15.0
    2.2
    4.3

Procedimientos con efectos laterales

    double[ ] tabB= new double[4];
    leer(tabB, "cont.txt");
    mostrar(tabB, 0, 3);

    0 -> 4.5
    1 -> 15.0
    2 -> 2.2
    3 -> 4.3

    void leer(double[ ] tab, String nom) {
      TextReader lect= new TextReader(nom);
      int i= 0;
      while (true) {
        double x= lect.readDouble();
        if (lect.eofReached())
          break;
        tab[i]= x;
        i= i+1;
      }
      lect.close();
    }

En una función o procedimiento, los parámetros que corresponden a algún tipo de objetos son en realidad referencias de objetos (recuerde que una referencia es como el teléfono celular del objeto). Por lo tanto, dentro del procedimiento leer, la variable tab referencia el mismo objeto que es referenciado por la variable tabB en la invocación de leer:

Funciones con efectos laterales

    double[ ] tabc= new double[1000]; // tabc está vacío
    int n= leer(tabC, "cont.txt");
    mostrar(tabC, 0, n-1);

    int leer2(double[ ] tab, String nom) {
      ... // idéntico a leer
      return i; // la última llave inicializada
    }

Observación:

En la primera versión de leer la asignación:

    int ult= leer(tabB, "cont.txt");

Experimento:

¿Qué despliega el siguiente programa?

    int i=1;
    double[ ] tabD= new double[1000];
    int ult= leer2(tabD, "cont.txt");
    println("leidos= "+i);

Funciones que retornan arreglos

    double[ ] tabE= leer3("cont.txt");
    mostrar(tab3);

    double[ ] leer3(String nom) {
      // Se lee una vez el archivo para determinar cuantos reales contiene
      TextReader lect= new TextReader(nom);
      int i= 0;
      while (true) {
        double x= lect.readDouble();
        if (lect.eofReached())
          break;
        i= i+1;
      }
      lect.close();
      int nelem= i;
      // volvemos a leer el archivo para llenarlo
      double[] tab= new double[nelem];
      lect= new TextReader(nom);
      i= 0;
      while (i<nelem) {
        tab[i]= lect.readDouble();
        i= i+1;
      }
      lect.close();
      return tab; // la última llave inicializada
    }

Término anticipado de una función

    return exp;

    boolean esPrimo(int n) {
      int i= 2;
      while (i<n) {
        if (n%i==0) {
          return false;
        }
        i= i+1;
      }
      return true;
    }