Las funciones dividen tareas grandes de computación en varias más pequeñas, y permiten la posibilidad de construir sobre lo que otros ya han hecho, en lugar de comenzar desde cero. Las funciones apropiadas ocultan los detalles de operación de las partes del programa que no necesitan saber acerca de ellos, así que dan claridad a la totalidad y facilitan la penosa tarea de hacer cambios.

El lenguaje C se diseñó para hacer que las funciones fueran eficientes y fáciles de usar; los programas escritos en C se componen de muchas funciones pequeñas en lugar de sólo algunas grandes. Un programa puede residir en uno o más archi­vos fuente, los cuales pueden compilarse por separado y cargarse junto con fun­ciones de biblioteca previamente compiladas. No trataremos aquí tales procesos, puesto que los detalles varían de un sistema a otro.

La declaración y definición de funciones es el área donde el estándar ANSI ha hecho los cambios más visibles a C. Tal como mencionam os en el capítulo 1, ahora es posible declarar los tipos de los argumentos cuando se declara una fun­ción. La sintaxis de la definición de funciones también cambia, de modo que las declaraciones y las definiciones coincidan. Esto hace posible que el compilador pueda detectar muchos más errores de lo que podía anteriormente. Además, cuando los argumentos se declaran con propiedad, se realizan automáticamente las conversiones convenientes.

El estándar clarifica las reglas sobre el alcance de los nombres; en particular, requiere que sólo haya una definición de cada objeto externo. La inicialización es más general: los arreglos y las estructuras automáticas ahora se pueden inicializar.

El preprocesador de C también se ha mejorado. Las nuevas facilidades del Procesador incluyen un conjunto más completo de directivas para la compilación condicional, una forma de crear cadenas entrecomilladas a partir de argumentos de macros y un mejor control sobre el proceso de expansión de macros.

Para comenzar, diseñemos y escribamos un programa que imprim a cada línea de su entrada que contenga un “patró n” o cadena de caracteres en particular.

(Este es un caso especial del programa grep de UNIX.) Por ejem plo, al buscar el patrón de letras “ould.” en el conjunto de líneas

Ah Love! could you and I with Fate conspire
To grasp this sorry Scheme of Things entire,
Would not we shatter it to bits -- and then
Re-mould it nearer to the Heart's Desire!

producirá la salida

Ah Love! could you and I with Fate conspire
Would not we shatter it to bits -- and then
Re-mould it nearer to the Heart's Desire!

El trabajo se ajusta ordenadamente en tres partes:

while {hay otra línea)
   if {la línea contiene el patrón)
      imprímela

Aunque ciertamente es posible poner el código de todo esto en main, una me­jor forma es aprovechar la estructura haciendo de cada parte una función separa­da. Es más fácil trabajar con tres piezas pequeñas que con una grande, debido a que los detalles irrelevantes se pueden ocultar dentro de las funciones, y minimi­zar así el riesgo de interacciones no deseadas. Los fragmentos incluso se pueden emplear en otros programas.

“Mientras hay otra línea” es getline, función que ya escribimos en el capítulo 1, e “imprímela” es printf, que alguien ya nos proporcionó. Esto significa que sólo necesitamos escribir una rutina para decidir si la línea contiene una ocurren­cia del patrón.

Podemos resolver ese problema escribiendo una función strindex(s,t), que re­gresa la posición o índice en la cadena s en donde comienza la cadena t, o -1 si s no contiene t. Debido a que los arreglos en C principian en la posición cero, los índices serán cero o positivos, y así un valor negativo como -1 es conveniente para señalar una falla. Cuando posteriormente se necesite una coincidencia de pa­trones más elaborada, sólo se debe reemplazar strindex; el resto del código pue­de permanecer igual. (La biblioteca estándar provee una función strstr que es semejante a strindex, excepto en que regresa un apuntador en lugar de un índice.)

Una vez definido todo este diseño, llenar los detalles del programa es simple. Aquí está en su totalidad, de modo que se puede ver cómo las piezas quedan juntas. Por ahora, el patrón que se buscará es una cadena literal, lo cual no es el mecanismo más general. Regresaremos en breve a una discusión sobre cómo inicializar arreglos de caracteres, y en el capítulo 5 mostraremos cómo hacer que el patrón de caracteres sea un parámetro fijado cuando se ejecuta el programa.

También hay una versión ligeramente diferente de getline, que se podrá compa­rar con la del capítulo 1.

# include <stdio.h>
#define MAXILINE 1000    /* longitud máxima por línea de entrada */
 
int getline(char line[], int max)
int strindex(char source[], char searchfor[]);
 
char pattern[] = "ould";     /* patrón a buscar */
 
/* encontrar todas las líneas que coincidan con el patrón */
main()
{
    char line[MAXLINE];
    int found = 0;
 
    while (getline(line, MAXLINE) > 0)
        if (strindex(line, pattern) >= 0) {
            printf("%s", line);
            found++;
        }
    return found;
}

/* getline: pone linea en s, retorna longitud */
int getline(char s[], int lim)
{
    int c, i;
 
    i = 0;
    while (--lim > 0 && (c=getchar()) != EOF && c != '\n')
        s[i++] = c;
    if (c == '\n')
        s[i++] = c;
    s[i] = '\0';
    return i;
}

/* strindex: retorna el índice de t en s, -1 si no hay */
int strindex(char s[], char t[])
{
    int i, j, k;
 
    for (i = 0; s[i] != '\0'; i++) {
        for (j=i, k=0; t[k]!='\0' && s[j]==t[k]; j++, k++)
            ;
        if (k > 0 && t[k] == '\0')
            return i;
    }
    return -1;
}

Cada definición de función tiene la forma

tipo-regresado nombre-de-función(declaraciones de argumentos)
{
    declaraciones y proposiciones
}

Varias partes pueden omitirse; una función mínima “dummy” es

nada() {}

que no hace ni regresa nada. Una función hacer-nada, como ésta, es algunas ve­ces útil para reservar lugar al desarrollar un programa. Si el tipo que regresa se omite, se supone int.

Un programa es sólo un conjunto de definiciones de variables y funciones. La comunicación entre funciones es por argumentos y valores regresados por las fun­ciones, y a través de variables externas. Las funciones pueden presentarse en cual­quier orden dentro del archivo fuente, y el programa fuente se puede dividir en varios archivos, mientras las funciones no se dividan.

La proposición return es el mecanismo para que la función que se llama regre­se un valor a su invocador. Al return le puede seguir cualquier expresión:

return expresión

La expresión se convertirá al tipo de retorno de la función si es necesario. Con frecuencia se utilizan paréntesis para encerrar la (expresión), pero son optativos.

La función que llama tiene la libertad de ignorar el valor regresado. Incluso, no hay necesidad de un a expresión después de return; en tal caso, ningún valor regresa al invocador. También el control regresa, sin valor, cuando la ejecución “cae al final” de la función al alcanzar la llave cerrada derecha }. No es ilegal, aunque probablemente un signo de problemas, el que una función regrese un va­lor desde un lugar y ninguno desde otro. En cualquier caso, si una función no regresa explícitamente un valor, su “valor” es ciertamente basura.

El programa de búsqueda del patrón regresa un estado desde main, el número de coincidencias encontradas. Este valor está disponible para ser empleado por el medio ambiente que llamó al programa.

El mecanismo de cómo compilar y cargar un programa en C que reside en va­rios archivos fuente varía de un sistema a otro. En el sistema UNIX, por ejemplo, la orden cc mencionada en el capítulo 1 hace el trabajo. Suponiendo que las tres funciones se almacenan en tres archivos llamados main.c, getline.c, y strin­dex.c. Entonces la orden

cc main.c getline.c strindex.c

compila los tres archivos, sitúa el código objeto resultante en los archivos main.o, getline.o, y strindex.o, y después los carga todos dentro de un archivo ejecutable llamado a.out. Si existe un error - digamos en main.c - dicho archivo pue­de volverse a compilar por sí mismo y el resultado cargado con los archivos objeto previos, con la orden.

cc main.c getline.o strindex.o

cc emplea la convención “.c” contra “.o” para distinguir los archivos fuente de los archivos objeto.

• Ejercicio 4-1. Escriba la función strrindex(s,t), que regresa la posición de la ocu­rrencia de más a la derecha de t en s, o -1 si no hay alguna.

Basta ahora los ejemplos de funciones han regresado o ningún valor (void) o un int. ¿Qué pasa si una función debe regresar algo de otro tipo? Muchas funciones numéricas como sqrt, sin y cos regresan double; otras funciones especiali­zadas regresan tipos diferentes. Para ilustrar cómo tratar con esto, escribamos y usemos la función atof(s), que convierte la cadena s a su valor equivalente de punto flotante de doble precisión. La función atoi es una extensión de atoi, de la que mostramos versiones en los capítulos 2 y 3. Maneja signo y punto decimal optativos, y presencia o ausencia de parte entera o fraccionaria. Nuestra versión no es una rutina de conversión de alta calidad; tomaría más espacio del que pode­mos dedicarle. La biblioteca estándar incluye un atof; el header <math.h> la declara.

Primero, atof por sí misma debe declarar el tipo del valor que regresa, puesto que no es int. El nombre del tipo precede al nombre de la función:

#include <ctype.h>
 
/* atof: convierte la cadena s a double */
double atof(char s[])
{
    double val, power;
    int i, sign;
 
    for (i = 0; isspace(s[i]); i++) /* saltea espacio en blanco */
        ;
    sign = (s[i] == '-') ? -1 : 1;
    if (s[i] == '+' || s[i] == '-')
        i++;
    for (val = 0.0; isdigit(s[i]); i++)
        val = 10.0 * val + (s[i] - '0');
    if (s[i] == '.')
        i++;
    for (power = 1.0; isdigit(s[i]); i++) {
        val = 10.0 * val + (s[i] - '0');
        power *= 10;
    }
    return sign * val / power;
}

Segundo, e igualmente importante, la rutina que llama debe indicar que atof regresa un valor que no es int. Una forma de asegurar esto es declarar atof explíci­tamente en la rutina que la llama. La declaración se muestra en esta primitiva cal­culadora (apenas adecuada para un balance de chequera), que lee un número por línea, precedido en forma optativa por un signo, y lo acumula, imprimiendo la suma actual después de cada entrada:

#include <stdio.h>
#define MAXLINE 100    /* calculadora rudimentaria * /
main()
{
    double sum, atof(char []);
    char line[MAXLINE];
    int getline(char line[], int max);
 
    sum = 0;
    while (getline(line, MAXLINE) > 0)
        printf("\t%g\n", sum += atof(line));
    return 0;
}

La declaración

double sum, atof(char []);

señala que sum es una variable double, y que atof es una función que toma un argumento char[] y regresa un double.

La función atof se debe declarar y definir consistentemente. Si atof en sí mis­ma y la llamada a ella en main tienen tipos inconsistentes dentro del mismo archi­vo fuente, el error será detectado por el compilador. Pero si (como es probable) atof fuera compilada separadamente, la falta de consistencia no se detectaría, atof regresaría un valor double que main trataría como int, y se producirían resultados incongruentes.

A la luz de lo que hemos mencionado acerca de cómo deben coincidir las de­claraciones con las definiciones, esto podría ser sorprendente. La razón de que ocurra una falta de coincidencia es que, si no existe el prototipo de una función, ésta es declarada implícitam ente la primera vez que aparece en una expresión, co­mo

sum += atof(line)

Si en una expresión se encuentra un nombre que no ha sido declarado previamen­te y está seguido por paréntesis izquierdo, se declara por contexto, de modo que se supone que es el nombre de una función que regresa un int, y nada se supone acerca de sus argumentos. Aún más, si la declaración de una función no incluye argumentos como en

double atof();

también es tomada de modo que no se supone nada acerca de los argumentos de atof; se desactiva toda revisión de parámetros. Este significado especial de la lista de argumentos vacía se hace para permitir que los programas en C viejos se compilen con los nuevos compiladores. Pero es una mala táctica usar esto con programas nuevos. Si la función toma argumentos, declárelos; si no los toma, use void.

Dado atof, propiamente declarado, podemos escribir atoi (convierte una cade­ na a int) en términos de él:

/* atoi: convierte la cadena s a entero usando atof */
int atoi(char s[])
{
double atof(char s[]);
return (int) atof(s);
}

Nótese la estructura de las declaraciones y la proposición return. El valor de la expresión en

return expresión;

se convierte al tipo de la función antes de que se tome el return. Por lo tanto, el valor de atof, un double, se convierte automáticamente a int cuando aparece en este return, puesto que la función atoi regresa un int. Sin embargo, esta opera­ción potencialmente descarta información, de manera que algunos compiladores lo previenen. El cast establece explícitamente lo que la operación intenta y suprime las advertencias.

• Ejercicio 4-2. Extienda atof para que maneje notación científica de la forma 123.45e-6 donde un número de punto flotante puede ir seguido por e o E y opcionalmente un exponente con signo. □

Continuar: Capítulo 5