Interacción con el usuario, controlada...Desarrollaremos aquí la macro que controla lo que el usuario ingresa por teclado.
Intentaremos mantenerla lo más breve y simple que sea posible,
pero también queremos que nos permita tomar decisiones importantes,
que sea versátil...
Las intenciones y objetivos detrás de una pieza de código son lo que realmente hace funcionar correctamente el algoritmo.Si se sabe lo que una macro o función se supone que tiene que hacer, entonces podemos usarla con confianza, y delegar al programador encargado de diseñar esa macro o función la responsabilidad de programarla correctamente.
La
macro BUI_SCANF() aceptará una lista de parámetros, que iremos especificando de a poco.
Lo primero que ha de hacer la
macro es leer una línea de texto de la entrada estándar, tecleada por el usuario. Para ello usaremos la función
gets().
Pero necesitamos una cadena de caracteres con la suficiente capacidad para albergar el texto tecleado.
Esa cadena será la componente
bui_input.buffer, de la estructura previamente definida
bui_input.
Ya tiene el tamaño apropiado, y no es necesario que el programador se ponga a definir nuevas variables.
Para eso la hemos puesto como parte inherente de la librería.
Sin embargo, es usual que a una sentencia de lectura de datos le anteceda un mensaje que informa al usuario el tipo de dato que se le solicita, y alguna otra información que pudiera hacer falta.
Esto será especificado en una variable de tipo
array de caracteres,
que el programador tiene que especificar a través de un parámetro de la
macro,
que llamaremos
REQ_MSG.
Así, la sentencia de lectura de datos del teclado será simplemente:
bui_gets(REQ_MSG);
Esta función mostrará en pantalla el mensaje contenido en
REQ_MSG, y luego leerá una línea de caracteres del teclado, guardándola en
bui_input.buffer.
Nota: Ya hemos discutido en mensajes previos las razones de por qué hemos evitado el uso directo de
scanf(), y cómo es que terminamos usando una combinación de
gets() con
sscanf().
Aquí sólo estamos reescribiendo esa experiencia previa en forma de una macro, que pueda accederse de manera universal desde cualquier archivo que invoque la librería
bui.h.
La siguiente sentencia es lo que ya esperamos: una relectura de los datos mediante
sscanf().
El escollo aquí es que
sscanf() es una función con un número variable de parámetros.

¿Cómo hacemos para pasar a una
macro una cantidad variable de parámetros?

¿Y cómo los invocamos dentro de la
macro?
Lo que se hace es poner al final de la lista de parámetros de la
macro 3 puntos suspensivos:
... Eso informa que la
macro acepta una cantidad variable de parámetros.
Para poder "incrustar" todos esos parámetros en alguna parte, basta escribir
__VA_ARGS__,
que es una palabra del preprocesador que sirve para sustituir por "lo que sea" que le hayamos arrojado como lista de parámetros a los puntos suspensivos.
La macro tendría esta cabecera, por ejemplo:
#define BUI_SCANF(REQ_MSG, ...)
Suponiendo que hemos puesto esos dichosos puntos suspensivos, podríamos escribir ahora confiados algo así:
sscanf(bui_input.buffer, __VA_ARGS__);
Esa instrucción toma como "entrada de datos" la cadena de caracteres
bui_input.buffer,
y luego toma como lista de parámetros a toda la lista variable de parámetros que el programador indica, en reemplazo de los puntos suspensivos.
Un modo de usar la macro sería por ejemplo esta:
BUI_SCANF("Ingrese sus datos!!!\n\n", "%d %f", nn, xx);
Los últimos 3 parámetros:
"%d %f", nn, xxreemplazan a los puntos suspensivos
...cada vez que en la
macro aparece la palabra
__VA_ARGS__.
Sería equivalente a haber escrito esto:
sscanf(bui_input.buffer, "%d %f", &nn, &xx);
Nota importante: En lo que sigue vamos a modificar todo este modo de uso.
Para tener un control más fino de la entrada de datos, tenemos que hacer como en posts anteriores: tener en cuenta el valor de retorno de
sscanf() para detectar posibles errores.
Si el valor de retorno es 0 ó positivo, indica la cantidad de variables que se pudieron "cargar" correctamente durante el proceso de
sscanf().
Si es negativo, indica
EOF, que a su vez significa que hubo algún otro tipo de error en la lectura de los datos.
Este dato lo guardaremos en la componente
bui_input.errno.
Así que nuestra sentencia debe cambiarse por esta otra:
bui_input.errno = sscanf(bui_input.buffer, __VA_ARGS__);
Para saber si todos las variables han sido correctamente asignadas durante el proceso de sscanf(),
tenemos que observar el valor de
bui_input.errno y ver si coincide con la cantidad de parámetros que aparecen en la cadena de formato
"%d %f".
Esa cantidad en este caso es 2, pero puede variar, claro está.
Lo que necesitamos es contar la cantidad de veces que aparece la directiva
% en la cadena de formato.
Y para eso necesitamos acceder desde la macro a dicha cadena de formato.
No nos sirve el enfoque de "haberla puesto sin nombre junto a toda la lista de parámetros
__VA_ARGS__".
Así que ese parámetros le daremos un nombre explícito en la cabecera de la
macro, digamos
FMT,
y sólo a partir de aquí consideraremos la lista variable de parámetros con los puntos suspensivos
...La cabecera de la macro quedaría por ahora así:
#define BUI_SCANF(REQ_MSG, FMT, ...)
La sentencia de invocación de
sscanf() quedará ahora así:
bui_input.errno = sscanf(bui_input.buffer, FMT, __VA_ARGS__);
Y ahora calculamos el número de directivas
% así:
__bui_N_ARGS(FMT)
Eso fue fácil.

En realidad la función
__bui_N_ARGS() ya la habíamos definido, sabiendo que la íbamos a necesitar.
Nota importante: La función
__bui_N_ARGS() no funciona a la perfección todavía. Requiere cambios en versiones futuras.
Reconoce como "variables efectivas" para ser asignadas, casos que no lo son.
Lo que nos interesa es, como dijimos, comparar esa cantidad con el número de error arrojado en
bui_input.errno.
Según la definición de
sscanf(), sabemos que el entero que retorna en
bui_input.errno nunca puede ser mayor que el número de directivas
% que aparece en la cadena de formato
FMT.
Ahí tenemos, pues, la siguiente aserción lógica:
/* bui_input.errno <= __bui_N_ARGS(FMT) */
Nunca se da el caso >.
Para saber si hubo un error, tenemos que ver si el lado izquierdo es estrictamente menor que el lado derecho.
El resultado de esto vamos a necesitarlo posteriormente en el programa,
así que lo vamos a guardar en la componente booleana
bui_input.error_state:
bui_input.error_state = (bui_input.errno < __bui_N_ARGS(FMT));
El valor de esta variable es
true en caso de que haya algún error,
y es
false en caso de que
sscanf() haya asignado correctamente todos los valores a cada uno de sus parámetros.
Ahora tenemos que tomar una decisión.
Si
bui_input.error_state es false, no hacemos nada, y dejamos que el programa fluya.
Si es true, hay dos opciones: o bien el programa termina, o bien muestra un mensaje de error y continúa normalmente.
En este último caso, la rutina principal que ha invocado la
macro tiene la responsabilidad de verificar si ha habido o no un error (mirando el valor de
bui_input.error_state), y entonces decidir qué hace en esa situación.
(Lo que nosotros venimos haciendo hasta ahora es "saltearnos" el trozo de código del bucle principal mediante un
continue;, que salta al principio del bucle para recomenzar).
El esquema de decisión sería éste:
if (bui_input.error_state)
if ( (evaluar_condicion_de_terminacion_del_programa ) )
/* Terminar el programa */
else
/* Mostrar mensaje de error */
else;
La condición para terminar el programa es algo que debe dejarse "abierto a todas las posibilidades",
ya que esto es decisión de diseño del programador.
No puede ser la librería
bui.h quien decida cuál es el mejor requisito para terminar un programa, pues es una
librería de servicios.
Sin embargo, podemos restringir un poco el universo de ocurrencias del programador,
diciendo que una "condición de terminación" es algo bien específico, por ejemplo:
Una función que acepta como entrada un parámetro de tipo cadena de caracteres,
y como salida envía un valor booleano, indicando true para "terminar" y false para "no terminar".Supongamos que, como hasta ahora, queremos que el programa termine cuando el usuario ha ingresado una cadena de caracteres con puros blancos.
En este caso, podemos usar la función
blank(), que por suerte ya la tenemos definida y funcionando correctamente.
Lo que haremos ahora será pasar el nombre de la función, es decir
blank,
como un parámetro a la
macro BUI_SCANF().
Ese parámetro indicará, pues, el nombre de una función cuyo cometido es dar una condición verdadera o falsa, para terminar o no el programa.
Entonces la cabecera de la macro se modificaría así:
#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, FMT, ...)
Como
TERMINATION_FUNC es sólo el "nombre" de una función, podemos intercalarlo alegremente dentro de la macro, usándola cuidadosamente para llamar funciones.
Sabiendo de antemano que esa función admite 1 parámetro de tipo cadena de caracteres, podemos escribir con tranquilidad lo siguiente:
TERMINATION_FUNC (bui_input.buffer)
Eso equivaldrá a reemplazar el parámetro
TERMINATION_FUNC por
blank, y entonces equivale a haber invocado:
blank (bui_input.buffer)
Debemos tener mucho cuidado con este tipo de manipulaciones.
Vemos, pues, que el uso de las macros es riesgoso, porque nada impide que un programador ponga cualquier cosa como parámetro. ¿Qué pasa si no pone una función, sino un
float, o un puntero?
Por ahora dejaremos esas preguntas sin responder.
Concentrémonos en lograr que las cosas funcionen, y después veamos los reparos técnicos.
El esquema de decisión tiene ahora este otro aspecto:
if (bui_input.error_state)
if ( TERMINATION_FUNC (bui_input.buffer) )
/* Terminar el programa */
else
/* Mostrar mensaje de error */
else;
Vemos que, cualquiera sea la función que indiquemos para determinar la condición de terminación,
va a actuar siempre sobre la variable
bui_input.buffer, que es una cadena de caracteres declarada en la librería
bui.h.
Es decir que las "condiciones de terminación" son condiciones establecidas sobre la cadena de caracteres que el usuario ha ingresado por teclado.
Esto es un diseño lógico, ya que esperamos que sea una decisión del usuario la que termine el programa.
Lo que puede cambiar es el tipo de entrada que el programa principal elige como indicador de "quiero terminar este programa de una vez por todas".
Una observación importante es que una
macro no es una
función.
Ni tampoco es una pieza de código que tenemos claramente a la vista.
Una
macro es un
caballo de Troya, del que no se sabe qué diablos saldrá de su interior.
En nuestro versión 1.10 de GCD habíamos puesto sentencias como
break, continue, o return.
Esas tres sentencias típicas de "quiebre" del flujo normal y secuencial del programa deben evitarse adentro de una macro, porque no se sabe cómo van a repercutir en la rutina principal que la invoca.
Por ejemplo, el caso de break es fuente segura de problemas.
Si la rutina que la invoca está dentro de un bloque
while(), la sentencia break causará que salgamos del
while().
Pero si estamos en un
switch(), que a su vez está dentro del while(), no se consigue el mismo efecto, porque el break sólo servirá para salir del switch().
Poniendo break, continue ó return dentro de las sentencias de una macro no permite predecir con exactitud hacia dónde se producirá el "salto".
La solución a este dilema es otorgar un mayor control sobre los saltos.
Esto se puede lograr con etiquetas claramente definidas y usando dentro de la macro una sentencia
goto, que se dirijan hacia esa etiqueta y no otra.
Ahí se acaba toda posible incertidumbre o ambigüedad.
Recordemos que las etiquetas y los saltos
goto tienen sentido en
C sólo dentro del bloque que abarca una función.
Lo que deberíamos hacer es pasar el nombre de la etiqueta como un parámetro más a la
macro BUI_SCANF, digamos
TERMINATION_LABEL, en la cabecera:
#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, FMT, ...)
Y dentro de la
macro, en el lugar donde se consigue una condición de "terminación", poner la sentencia:
goto TERMINATION_LABEL;
Esto hará el trabajo.
Nuestro esquema de decisión se va completando mejor, y ahora tenemos esto:
if (bui_input.error_state)
if ( TERMINATION_FUNC (bui_input.buffer) )
goto TERMINATION_LABEL;
else
/* Mostrar mensaje de error */
else;
Ahora, si en nuestro programa ponemos una etiqueta llamada
fin_programa:antes del final, invocaríamos a BUI_SCANF() así:
int main(void) {
BUI_SCANF("Ingrese sus datos aquí: \n\n", blank, fin_programa, "%d %f", nn, xx);
/* sentencias varias... */
fin_programa:
return 0;
}
Todos estamos acostumbrados a oír la eterna canción de
"No uses goto en la programación."Eso se repite una y otra vez como un mantra religioso.
En realidad en la programación "hay que hacer lo que hay que hacer", según la situación que corresponda, para bien del programa que estamos desarrollando.
Me causan mucha risa

las prevenciones morales en el terreno informático.

En realidad lo que no habría que usar son las
macros.

Esas sí que son peligrosas.
Pero entonces, ya que estamos haciendo un diseño basado en una
macro,
tenemos que ponernos en situación, y advertir que hay acciones peligrosas dentro de una
macro.
En este caso, el uso de sentencias aparentemente seguras como
break, continue, return,
conducen ahora a resultados impredecibles en el momento del diseño,
y lo más saludable es controlar los saltos con
etiquetas bien especificadas,
para decirle a la
macro exactamente a dónde queremos que vaya,
y esto trae como consecuencia la necesidad de hacer los saltos con
goto hacia esas
etiquetas.
En este caso, lo más "seguro" es usar
goto.
En caso de que la condición de terminación no se dé,
la alternativa es mostrar un mensaje de error que informe al usuario lo que ha ocurrido,
y que le indique además cómo salir del error, o qué hacer a continuación.
Este mensaje de error será una cadena de caracteres que debe elegirse desde la rutina invocadora,
y por lo tanto es un parámetro adicional, digamos
ERROR_MSG, que tendremos que pasar a la macro
BUI_SCANF().
La cabecera quedará así:
#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, FMT, ...)
Ahora el esquema de decisión queda completo, así:
if (bui_input.error_state)
if (TERMINATION_FUNC (bui_input.buffer))
goto TERMINATION_LABEL;
else
printf(ERROR_MSG);
else;
Habiendo explicado todos los aspectos de la
macro BUI_SCANF(), estamos en condiciones de mostrarla en su forma final, que sería ésta:
#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, FMT, ...) { \
bui_gets(REQ_MSG); \
bui_input.errno = sscanf(bui_input.buffer, FMT, __VA_ARGS__); \
\
bui_input.error_state = (bui_input.errno < __bui_N_ARGS(FMT)); \
if (bui_input.error_state) \
if (TERMINATION_FUNC (bui_input.buffer)) \
goto TERMINATION_LABEL; \
else \
printf(ERROR_MSG); \
else; \
}
Todos los caracteres
\ que aparecen al final de cada línea son necesarios en la definición de una
macro, para indicar que en realidad se trata de una línea que "continúa debajo".
Hemos puesto el código de la
macro "entre llaves", cuando no es estrictamente necesario,
ya que no es una función.
Pero el uso de llaves encierra bien las sentencias, dando lugar a código más seguro, evitando errores sintácticos indeseables o inentendibles.
La librería bui.h está lista.
Le pondemos número de versión 1.20, para seguir con la numeración que traíamos desde GCD,
aunque no tengan ahora nada que ver una cosa con la otra.
Ya hemos independizado por completo la interface de usuario con la rutina matemática GCD.
El archivo luce así (en spoiler):
Spoiler
bui0120.h:
/* ========================================================================= */
/* BUI.H 1.20 (Basic User Interface)
/*
/* Esta librería da una interface básica para presentar programas simples en C
/*
/* 2013/ago/18
/* rinconmatematico.com
/* Argentinator
/*
/* ========================================================================= */
#include <ctype.h>
#include <stdbool.h>
#include <stdio.h>
#define __SHORT_STR_LEN 32 /* Longitud string corta. */
#define __LONG_STR_LEN 1024 /* Longitud string larga. */
#define __MAX_LIST 16 /* Longitud de listas de varios ítems en bui.h */
struct {
char
program_name[__SHORT_STR_LEN],
program_vers[__SHORT_STR_LEN],
program_auth[__SHORT_STR_LEN],
program_date[__SHORT_STR_LEN],
program_coun[__SHORT_STR_LEN],
program_purp[__LONG_STR_LEN],
program_comm[__LONG_STR_LEN],
program_comm_[__MAX_LIST][__LONG_STR_LEN],
program_help[__LONG_STR_LEN],
program_help_[__MAX_LIST][__LONG_STR_LEN],
program_req[__LONG_STR_LEN],
program_req_[__MAX_LIST][__LONG_STR_LEN],
program_mess[__LONG_STR_LEN],
program_mess_[__MAX_LIST][__LONG_STR_LEN],
program_err[__LONG_STR_LEN],
program_err_[__MAX_LIST][__LONG_STR_LEN];
} bui;
#define __INPUT_STR_LEN 130 /* Longitud string datos entrados por teclado. */
struct {
char buffer[__INPUT_STR_LEN];
int errno;
bool error_state;
} bui_input;
bool blank(char* );
void bui_show_program_info(void);
void bui_print_list(char (*list)[__LONG_STR_LEN]);
void bui_set_string(char* restrict, const char* restrict);
/* Macro:
/* BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, FMT, ...)
/* */
/* ========================================================================= */
void bui_show_program_info(void) {
printf("%s %s\n%s %s\n%s\n\n",
bui.program_name, bui.program_vers,
bui.program_date, bui.program_coun,
bui.program_auth,
bui.program_comm
);
}
void bui_print_list(char (*list)[__LONG_STR_LEN]) {
for (int i = 0; i < __MAX_LIST; i++)
if (list[i][0])
printf("%s", list[i]);
}
void bui_set_string(char* restrict dest, const char* restrict src) {
/* Copia src en dest */
for( ; (*dest = *src) != '\0'; src++, dest++)
;
}
void bui_gets(char *req) {
printf("%s", req);
gets(bui_input.buffer);
}
int __bui_N_ARGS(char *s) {
int n;
bool before = false;
for (n = 0; *s; s++)
if (*s == '%')
before = true;
else {
if (before)
n++;
before = false;
}
return n;
}
bool blank(char *s) {
for ( ; *s; ++s)
if (!isspace(*s))
/* Se ha encontrado un caracter que no es blanco. */
return false;
/* s es una string que sólo contiene blancos */
return true;
}
#define BUI_SCANF(REQ_MSG, TERMINATION_FUNC, TERMINATION_LABEL, ERROR_MSG, FMT, ...) { \
bui_gets(REQ_MSG); \
bui_input.errno = sscanf(bui_input.buffer, FMT, __VA_ARGS__); \
\
bui_input.error_state = (bui_input.errno < __bui_N_ARGS(FMT)); \
if (bui_input.error_state) \
if (TERMINATION_FUNC (bui_input.buffer)) \
goto TERMINATION_LABEL; \
else \
printf(ERROR_MSG); \
else; \
}
/* Quitamos las definiciones de los símbolos definidos en la librería */
/* para que queden inaccesibles desde archivos externos. */
#undef __INPUT_STR_LEN
#undef __SHORT_STR_LEN
#undef __LONG_STR_LEN
#undef __MAX_LIST
La versión 1.20 del programa GCD ahora quedará muy breve, pues se limita a invocar librerías, funciones y macros, y controlar el flujo del programa.
Sin embargo, a nuestro programa le queda todavía una tarea importante:
* Definir todas las cadenas de caracteres que dan información al usuario.
Esto lo haremos en una función llamada
start(),
en donde definiremos las componentes que nos interesen de la estructura
bui.
Veamos el programa completo directamente, ya que será fácil de interpretar:
Spoiler
gcd0120.c:
/* ========================================================================= */
/* GCD 1.20
/*
/* Este programa calcula el máximo común divisor de dos números enteros.
/*
/* 2013/ago/17
/* rinconmatematico.com
/* Argentinator
/*
/* ========================================================================= */
#include "bui0120.h"
#include "gcd0110.h"
void start(void);
int main(void) {
start();
do {
int m, n;
BUI_SCANF( bui.program_req,
blank, end_program, bui.program_err,
"%d %d", &m, &n
);
if (bui_input.error_state)
continue;
int ans = gcd(m, n);
printf(((ans >= 0)? "gcd(%i,%i) = %i\n\n": "gcd(0, 0) = INFINITO\n\n"), m, n, ans);
} while (1);
end_program:
return 0;
}
void start(void) {
bui_set_string(bui.program_name, "GCD");
bui_set_string(bui.program_vers, "01.20");
bui_set_string(bui.program_auth, "Argentinator");
bui_set_string(bui.program_date, "2013/Ago/18");
bui_set_string(bui.program_coun, "");
bui_set_string(bui.program_comm,
"Este programa calcula el M.C.D. de dos nros. enteros\n"
"Si ambos valores son nulos, el resultado es INFINITO.\n"
);
bui_set_string(bui.program_req,
"Escriba dos enteros separados por un caracter blanco\n"
"(o digite un ESPACIO seguido de ENTER para terminar).\n\n"
);
bui_set_string(bui.program_err,
"\nDatos no validos.\n"
"Se requieren dos numeros enteros.\n"
"Intente nuevamente.\n\n"
);
bui_show_program_info();
}
Vemos que en
start() hacemos uso de las funciones
bui_set_string(), que usamos para asignar cadenas de caracteres concretas a las componentes de la estructura
gui.
No hace falta asignar valores a todas las componentes.
Luego invocamos la función
bui_show_program_info(), que muestra los datos básicos del programa.
Esos datos al menos sí tendrían que ser bien asignados en las líneas precedentes.
Observemos cómo el programa se controla con un bucle que ahora es muy sencillo de interpretar:
* Primero lee datos del teclado con BUI_SCANF(),
* luego verifica si hubo un error (y en tal caso reinicia el bucle),
* y si toda está correcta realiza el cálculo del máximo común divisor y muestra los resultados.
* Por último, el bucle se repite indefinidamente.
A nuestro programa le faltan algunos comentarios, por ejemplo unos que informen un poco mejor sobre las condiciones bajo las cuales el programa termina. Esto lo haremos luego.