Funciones en C: declarar, llamar y devolver valores

Por qué funciones

Todo hasta ahora ha vivido dentro de main. Eso funciona hasta que un programa hace más de una cosa, y entonces llegan tres problemas a la vez: el mismo bloque de código se copia en tres lugares, main crece más allá de lo que alguien puede tener en la cabeza y no hay forma de nombrar para qué sirve un trozo de código.

Una función arregla los tres. Le da a un bloque de código un nombre, sus propias variables locales, una lista de entradas y un único valor para devolver.

#include <stdio.h>

int square(int n) {
    return n * n;
}

int main(void) {
    printf("%d\n", square(4));
    printf("%d\n", square(9));
    printf("%d\n", square(square(2)));
    return 0;
}

square se escribe una vez y se llama tres, incluida una sobre su propio resultado. Ya llevas rato llamando funciones: printf es una, y main también.

Anatomía de una función

tipoDeRetorno nombre(listaDeParametros) {
    // cuerpo
    return valor;
}

Cuatro partes:

• Tipo de retorno: el tipo del valor que la función devuelve. int, double, char, un tipo puntero o void para "nada".
• Nombre: sigue las mismas reglas que el nombre de una variable, y debería decir qué hace o qué produce la función.
• Lista de parámetros: las entradas, cada una con su propio tipo, separadas por comas. (void) significa que no toma ninguna.
• Cuerpo: las sentencias, entre llaves, terminando con un return salvo que el tipo de retorno sea void.

#include <stdio.h>

/* toma dos ints, produce un int */
int add(int a, int b) {
    return a + b;
}

/* no toma nada, produce un double */
double pi(void) {
    return 3.14159265358979;
}

/* toma un int, no produce nada */
void printBanner(int width) {
    for (int i = 0; i < width; i++) {
        printf("=");
    }
    printf("\n");
}

int main(void) {
    printBanner(20);
    printf("2 + 3 = %d\n", add(2, 3));
    printf("pi    = %f\n", pi());
    printBanner(20);
    return 0;
}

Fíjate en que pi() sigue necesitando los paréntesis vacíos en el punto de llamada: eso es lo que la convierte en una llamada y no en una mención del nombre. Y printBanner(20); es una sentencia por sí sola, porque no produce ningún valor que usar.

Escribe (void), no (), para una función sin parámetros. En C esas dos cosas significan algo distinto, y () es la laxa; más sobre esto en un momento.

Llamar y devolver

Una llamada transfiere el control a la función, ejecuta su cuerpo y vuelve con un valor que sustituye a la llamada dentro de la expresión que la rodea.

#include <stdio.h>

int larger(int a, int b) {
    if (a > b) {
        return a;      /* sale de la funcion de inmediato */
    }
    return b;
}

int main(void) {
    int x = larger(17, 42);
    printf("larger(17, 42) = %d\n", x);
    printf("anidado: %d\n", larger(larger(3, 9), 5));
    return 0;
}

return hace dos cosas a la vez: aporta el valor y termina la función en el acto. Nada de lo que venga después de un return en el mismo camino llega a ejecutarse, que es lo que hace funcionar el estilo de retorno temprano de larger: no hace falta ningún else, porque llegar a la última línea ya significa que a > b era falso.

Una función puede tener varias sentencias return. Solo puede ejecutar una de ellas por llamada.

Funciones void

Una función que existe por su efecto y no por su valor tiene el tipo de retorno void: imprimir, actualizar algo a través de un puntero, dibujar.

#include <stdio.h>

void printTable(int n, int upTo) {
    for (int i = 1; i <= upTo; i++) {
        printf("%d x %d = %d\n", n, i, n * i);
    }
}

void warn(const char *message, int enabled) {
    if (!enabled) {
        return;            /* return a secas: solo salir antes */
    }
    printf("AVISO: %s\n", message);
}

int main(void) {
    printTable(7, 5);
    warn("queda poco espacio en disco", 1);
    warn("este esta suprimido", 0);
    return 0;
}

Dentro de una función void, return; sin valor sale antes de tiempo. return algunValor; ahí es un error de compilación, y también lo es usar la llamada dentro de una expresión: int x = printTable(7, 5); no compila, que es el sistema de tipos haciendo su trabajo.

Descomposición: el verdadero objetivo

Las funciones no van sobre todo de evitar la repetición. Van de convertir un procedimiento largo en unos pocos pasos con nombre, de modo que main se lea como una descripción del programa y no como su implementación.

#include <stdio.h>

double average(const int values[], int count) {
    if (count == 0) {
        return 0.0;
    }
    int total = 0;
    for (int i = 0; i < count; i++) {
        total += values[i];
    }
    return (double) total / count;
}

int highest(const int values[], int count) {
    int best = values[0];
    for (int i = 1; i < count; i++) {
        if (values[i] > best) {
            best = values[i];
        }
    }
    return best;
}

int countAbove(const int values[], int count, int threshold) {
    int n = 0;
    for (int i = 0; i < count; i++) {
        if (values[i] > threshold) {
            n++;
        }
    }
    return n;
}

int main(void) {
    int scores[] = {88, 92, 75, 60, 100, 47, 83};
    int n = sizeof(scores) / sizeof(scores[0]);

    double avg = average(scores, n);

    printf("Cantidad:            %d\n", n);
    printf("Promedio:            %.2f\n", avg);
    printf("Maximo:              %d\n", highest(scores, n));
    printf("Por encima del promedio: %d\n", countAbove(scores, n, (int) avg));
    return 0;
}

main son ahora cuatro líneas de salida y un cálculo. Cada auxiliar hace una sola cosa, tiene un nombre que dice cuál es y se puede probar por separado. Fíjate en que la longitud del array viaja como segundo parámetro: una vez que un array se pasa a una función, el truco de sizeof deja de funcionar ahí, porque el array decae a un puntero.

Tres reglas prácticas para repartir el trabajo en funciones:

• Un trabajo por función. Si el nombre necesita una "y" dentro, probablemente son dos funciones.
• Toma lo que necesites, devuelve lo que produzcas. Una función que lee estado global cuesta más de razonar y es imposible de probar de forma aislada.
• Lo bastante corta para verla de una vez. No hay un número mágico de líneas, pero una función que no cabe en una pantalla suele esconder otra función más pequeña dentro.

Funciones que llaman a funciones

Una función puede llamar a cualquier función que ya haya sido declarada, incluidas las que escribiste tú:

#include <stdio.h>

int isEven(int n) {
    return n % 2 == 0;
}

int sumEvens(const int a[], int n) {
    int total = 0;
    for (int i = 0; i < n; i++) {
        if (isEven(a[i])) {
            total += a[i];
        }
    }
    return total;
}

void report(const int a[], int n) {
    printf("Suma de los valores pares: %d\n", sumEvens(a, n));
}

int main(void) {
    int data[] = {3, 8, 12, 5, 7, 20};
    report(data, sizeof(data) / sizeof(data[0]));
    return 0;
}

main llama a report, que llama a sumEvens, que llama a isEven dentro de un bucle. Cada llamada recibe su propio conjunto nuevo de variables locales, apilado encima del de quien la llamó, y se descartan cuando retorna.

Las definiciones de arriba están en orden de dependencia —isEven antes que sumEvens antes que report— porque C exige que una función esté declarada antes de llamarla. Llama a una que aparezca más abajo en el archivo y el compilador se queja de una declaración implícita. La solución general es un prototipo cerca del inicio del archivo, que te deja ordenar las definiciones como quieras. Una función que se llama a sí misma también es legal y útil; eso es la recursión.

main es una función

main es una función corriente que el entorno de ejecución llama por ti. Su tipo de retorno int es el estado de salida del programa: 0 significa éxito, distinto de cero significa fallo, y los scripts de shell y las herramientas de compilación lo leen.

int main(void) {
    /* ... */
    return 0;
}

Desde C99, llegar al final de main sin un return devuelve 0 implícitamente, una regla especial que se aplica solo a main. Cualquier otra función que no sea void y termine sin devolver un valor produce comportamiento indefinido cuando quien la llamó usa el resultado.

La otra forma estándar es int main(int argc, char *argv[]), que recibe los argumentos de la línea de comandos. Ambas son correctas; void main() no lo es, digan lo que digan los tutoriales viejos.

Errores comunes

• Olvidar el return en una función que no es void. Quien llama lee entonces un valor basura. gcc -Wall avisa.
• Declarar dentro del cuerpo una variable con el mismo nombre que un parámetro. Oculta al parámetro, y la asignación que querías hacerle a la entrada no va a ninguna parte.
• Esperar que una función cambie sus argumentos. C pasa todo por valor, así que una función recibe copias. void reset(int x) { x = 0; } no cambia nada en el punto de llamada: el tema de la siguiente página.
• Omitir los paréntesis en una llamada. printBanner; es una expresión legal que evalúa la dirección de la función y la descarta. Compila, no hace nada, y -Wall lo señala.
• Escribir () en lugar de (void). Es legal, pero desactiva la comprobación de argumentos en los dialectos antiguos de C.