Quienes hayan usado
scanf() para leer datos habrán tropezado más de una vez con extrañas e indeseables vicisitudes.
Puede que sea un problema de la distribución (la mía es
(MINGW) GCC 4.7).
Como sea, eso me ha motivado a "postergar" la lectura de los datos ingresados por el usuario en la entrada estándar (teclado), que en
C es un archivo que se llama
stdio (en la librería estándar
stdio.h).
Ya he comentado antes la técnica básica para esto:
gets(buffer);
sscanf(buffer, "%formatos...", &variables...);
La función
gets() lee una línea completa del teclado hasta alcanzar el fin de línea
'\n'.
El caracter
'\n' es descartado y reeplazado por el caracter nulo
'\0'.
El resultado se guarda en
buffer, que es una variable de tipo
char[].
Pero aquí surge un nuevo problema:
* ¡La función gets() no es segura!

La razón de esto es simple: si del teclado se han leído más caracteres que los que caben en el array de caracteres
buffer[], entonces no hay espacio suficiente, y se produce una
sobreescritura de posiciones prohibidas de la memoria, causando estragos en el programa, y en el sistema.
Usar
gets() es un pecado en la "religión" de la informática.
(Hay una conspiración global contra el uso de
goto, pero yo digo que el
goto no es grave, si se lo sabe usar bien. De hecho, esto le pasa a cualquier aspecto de un lenguaje de programación. En cambio el uso de
gets() sí tiene que estar prohibido, porque el programador no puede controlar sus efectos).
Para evitar esto, hay que usar algún mecanismo análogo a
gets(), pero que impida que se lean más caracteres que los que puede albergar el buffer.
Por suerte en
stdio.h hay una alternativa que es la función
fgets(): Lee líneas de archivos de texto, hasta una cantidad especificada como máximo de caracteres.
El archivo de texto que nos interesa leer es
stdin: la entrada estándar (o teclado).
Si
buffer es un array de
N caracteres,
entonces tendríamos que leer así:
fgets(buffer, N, stdin);Esta sentencia lee
N - 1

caracteres de
stdin (o sea el teclado), agrega un caracter nulo
'\0',
y el resultado lo pone en
buffer.
Uno de los caracteres leídos y guardados en
buffer será el fin de línea
'\n' (cosa que no ocurría con
gets()).
Listo, ya no hay problemas de sobreescritura de memoria...

Pero se arruina todo de nuevo

porque si el usuario teclea más que
N - 1 caracteres,
estos quedan en la
"cola de espera" de
stdin,
y serán tomados como caracteres válidas en una próxima lectura de
stdin,
ya sea que se haga con
fgets(..., stdin), gets(), getchar() o scanf().
Esto es un nuevo problema a resolver.
Lo que necesitamos es detectar si se ha presionado o no la tecla
ENTER, y en caso negativo, seguir leyendo caracteres de la "cola de espera" de
stdin hasta encontrar un fin de línea
'\n'.
¿Cómo se hace esto?

Para resolver la cuestión, no nos salgamos de contexto, porque la solución puede no ser aplicable en todos los casos.
Hemos leído datos con
fgets(buffer, N, stdin), y queremos determinar si se ha alcanzado el fin de línea o no.
Si
buffer contiene algún
'\n', quiere decir que
fgets() lo ha leído y guardado allí, y que en la posición siguiente hay un
'\0'.
Pero este caso no nos interesa...
Lo que nos interesa es saber cuándo
NO HAY '\n' en
buffer, o sea, cuándos
fgets() no alcanzó a leer hasta el fin de línea.
Si esto ha ocurrido, entonces el
buffer está lleno hasta la posición \( N-2 \) de caracteres distintos de
'\n' y
'\0'. Y hay un
'\0' en la posición \( N-1 \).
Recíprocamente, si estas condiciones ocurren, quiere decir también que el fin de línea no se ha alcanzado, porque en ese caso el
buffer se ha llenado hasta la posición \( N-2 \) con datos distintos al fin de línea.
Por lo tanto, es sencillo saber la condición lógica que debe cumplirse en el programa para saber si el fin de línea se ha alcanzado o no:
fgets(buffer, N, stdin) pudo alcanzar el fin de línea
si y sólo si (buffer[N-2] != '\0') && (buffer[N-2] != '\n')
Si esta condición se cumple, leemos con
getchar() sucesivos caracteres de stdin hasta encontrar el próximo fin de línea
'\n':
while(getchar() != '\n')
; /* sentencia vacía */
Todo esto funciona si el número de caracteres del buffer satisface \( N \geq 2 \).
¿Qué pasa si \( N == 1 \)?
En este caso sólo hay espacio en el
buffer para 1 caracter: el nulo
'\0'.
O sea que la llamada
fgets(buffer, 1, stdin) nunca alcanza el fin de línea.
Aquí
siempre habrá que "limpiar" la "cola de espera" buscando el próximo fin de línea.
Hay otro problema.

La variable
buffer[] puede que sea utilizada en el programa para diversas cosas que al programador se le ocurran, y entonces
fgets() no tiene el control de lo que ocurre con los caracteres del array.
Por lo tanto, puede que a veces en la posición
buffer[N-2] haya un caracter distinto del fin de línea y del nulo, aún en el caso en que
fgets() haya leído el fin de línea.
Esto sólo puede ocurrir si previamente había información "basura" en
buffer[].
Lo ideal sería limpiar toooooodo el array
buffer[], rellenando con
'\0' todos las posiciones.
Sin embargo esto es ineficiente, y además es innecesario.
Dado que la única posición que nos preocupa es
buffer[N-2], basta conque limpiemos esa sola posición de memoria, ya que la "basura" de las otras posiciones no nos afecta en modo alguno.
Limpiar 1 solo caracter es más eficiente, y no importa cuán grande sea N, se tarda siempre lo mismo en esta tarea de "limpieza" tan sencilla:
buffer[N-2] = '\0';Por fin hemos terminado de analizar todos los casos.
Ahora podemos poner todo junto en una función que haga el trabajo.
Con comentarios y todo, queda así:
/* Se usa la función "segura" fgets() en vez de gets() */
/* No permite al usuario ingresar cadenas de longitud mayor que el buffer. */
/* buffer debe tener al menos N caracteres disponibles. */
/* Si buffer no es un array con tamaño suficiente, nb_gets() no es válida. */
char* nb_gets(char *buffer, int N) {
if (N <= 0)
/* No hay espacio para leer */
return NULL;
/* N >= 1 */
if (N == 1) {
/* Sólo hay espacio para el caracter nulo */
fgets(buffer, N, stdin);
/* buffer[0] == '\0'; */
/* Se han leído N - 1 == 0 caracteres */
/* ---> No se ha podido leer el fin de línea */
while(getchar()!='\n')
;
return buffer;
};
/* N >= 2 */
buffer[N-2] = '\0'; /* Limpieza rápida del buffer (ver abajo) */
fgets(buffer, N, stdin);
/* Se cumple la siguiente propiedad: */
/* (no_se_alcanzó_fin_de_línea) */
/* <----> */
/* (buffer[N-2] != '\0') && (buffer[N-2] != '\n') */
/* Por lo tanto es suficiente limpiar el caracter .buffer[N-2] */
if ((buffer[N-2] != '\0') && (buffer[N-2] != '\n'))
/* No se ha alcanzado el fin de línea */
while ( getchar() != '\n' ) /* flush_stdin... */
/* ---> produce una descarga de stdin */
/* descartando caracteres hasta llegar al fin de línea */
/* */ ;
/* else ; */
/* Sí se ha alcanzado el fin de línea: no se hace nada. */
return buffer;
}
Si queremos verla limpia de tandos comentarios y aserciones, queda esto:
char* nb_gets(char *buffer, int N) {
if (N <= 0)
/* No hay espacio para leer */
return NULL;
if (N == 1) {
fgets(buffer, N, stdin);
while(getchar() != '\n')
;
return buffer;
};
buffer[N-2] = '\0'; /* Limpieza rápida del buffer (ver abajo) */
fgets(buffer, N, stdin);
if ((buffer[N-2] != '\0') && (buffer[N-2] != '\n'))
while (getchar() != '\n')
;
return buffer;
}