¿Cómo borrar el búfer de entrada en C?

Tengo el siguiente programa:

int main(int argc, char *argv[])
{
  char ch1, ch2;
  printf("Input the first character:"); // Line 1
  scanf("%c", &ch1); 
  printf("Input the second character:"); // Line 2
  ch2 = getchar();

  printf("ch1=%c, ASCII code = %d\n", ch1, ch1);
  printf("ch2=%c, ASCII code = %d\n", ch2, ch2);

  system("PAUSE");  
  return 0;
}

Como ha explicado el autor del código anterior: El programa no funcionará correctamente porque en la Línea 1, cuando el usuario presione Enter, dejará en el búfer de entrada 2 el carácter: Enter key (ASCII code 13)y \n (ASCII code 10). Por lo tanto, en la Línea 2, leerá el \ny no esperará a que el usuario ingrese un carácter.

OK, tengo esto. Pero mi primera pregunta es: ¿Por qué el segundo getchar()( ch2 = getchar();) no lee el carácter Enter key (13), en lugar de \n?

A continuación, el autor propuso 2 formas de resolver tales problemas:

1. utilizar fflush()

2. escribe una función como esta:

   void
   clear (void)
   {    
     while ( getchar() != '\n' );
   }
   

Este código funcionó realmente. ¿Pero no puedo explicarme cómo funciona? Porque en la declaración while, usamos getchar() != '\n', eso significa leer cualquier carácter excepto '\n'? si es así, en el búfer de entrada aún permanece el '\n'carácter?

El programa no funcionará correctamente porque en la Línea 1, cuando el usuario presiona Enter, dejará en el búfer de entrada 2 el carácter: Tecla Enter (código ASCII 13) y \ n (código ASCII 10). Por lo tanto, en la Línea 2, leerá \ n y no esperará a que el usuario ingrese un carácter.

El comportamiento que ves en la línea 2 es correcto, pero esa no es la explicación correcta. Con las transmisiones en modo texto, no importa qué finales de línea use su plataforma (ya sea retorno de carro (0x0D) + salto de línea (0x0A), un CR simple o un LF simple). La biblioteca de tiempo de ejecución de C se encargará de eso por usted: su programa verá solo las '\n'nuevas líneas.

Si escribió un carácter y presionó enter, entonces ese carácter ingresado se leerá en la línea 1 y luego '\n'se leerá en la línea 2. Vea Estoy usando scanf %cpara leer una respuesta S / N, pero la entrada posterior se salta.de las preguntas frecuentes de comp.lang.c.

En cuanto a las soluciones propuestas, consulte (nuevamente de las preguntas frecuentes de comp.lang.c):

• ¿Cómo puedo eliminar la entrada pendiente para que la escritura anticipada de un usuario no se lea en el siguiente mensaje? ¿ fflush(stdin)Funcionará?
• Si fflushno funciona, ¿qué puedo usar para eliminar la entrada?

que básicamente establecen que el único enfoque portátil es hacer:

int c;
while ((c = getchar()) != '\n' && c != EOF) { }

Su getchar() != '\n'ciclo funciona porque una vez que llama getchar(), el carácter devuelto ya ha sido eliminado del flujo de entrada.

Además, me siento obligado a disuadirlo de consumir por scanfcompleto: ¿Por qué todos dicen que no lo use scanf? ¿Qué debo usar en su lugar?

Puedes hacerlo (también) de esta manera:

fseek(stdin,0,SEEK_END);

Una forma portátil de borrar hasta el final de una línea que ya ha intentado leer parcialmente es:

int c;

while ( (c = getchar()) != '\n' && c != EOF ) { }

Esto lee y descarta caracteres hasta que obtiene lo \nque indica el final del archivo. También verifica EOFen caso de que el flujo de entrada se cierre antes del final de la línea. El tipo de cdebe ser int(o mayor) para poder mantener el valor EOF.

No hay una forma portátil de averiguar si hay más líneas después de la línea actual (si no las hay, getcharse bloqueará la entrada).

Las líneas:

int ch;
while ((ch = getchar()) != '\n' && ch != EOF)
    ;

no lee solo los caracteres antes del salto de línea ('\n' ). Lee todos los caracteres de la secuencia (y los descarta) hasta el siguiente salto de línea (o se encuentra EOF) incluido . Para que la prueba sea verdadera, primero debe leer el salto de línea; así que cuando el bucle se detiene, el salto de línea fue el último carácter leído, pero se ha leído.

En cuanto a por qué lee un salto de línea en lugar de un retorno de carro, es porque el sistema ha traducido el retorno a un salto de línea. Cuando se presiona enter, eso indica el final de la línea ... pero la secuencia contiene un avance de línea en su lugar, ya que ese es el marcador normal de fin de línea para el sistema. Eso podría depender de la plataforma.

Además, el uso fflush()en un flujo de entrada no funciona en todas las plataformas; por ejemplo, generalmente no funciona en Linux.

¿Pero no puedo explicarme cómo funciona? Porque en la instrucción while, usamos getchar() != '\n', eso significa leer cualquier carácter excepto '\n'?? si es así, en el búfer de entrada aún permanece el '\n'carácter ??? ¿Estoy entendiendo mal algo?

Lo que quizás no se dé cuenta es que la comparación ocurre después de getchar() eliminar el carácter del búfer de entrada. Entonces, cuando llegas al '\n', se consume y luego sales del bucle.

puedes probar

scanf("%c%*c", &ch1);

donde% * c acepta e ignora la nueva línea

un método más en lugar de fflush (stdin) que invoca un comportamiento indefinido que puede escribir

while((getchar())!='\n');

no olvides el punto y coma después del ciclo while

Encuentro un problema al intentar implementar la solución.

while ((c = getchar()) != '\n' && c != EOF) { }

Publico un pequeño ajuste 'Código B' para cualquiera que tenga el mismo problema.

El problema fue que el programa me mantuvo capturando el carácter '\ n', independientemente del carácter de entrada, aquí está el código que me dio el problema.

Código A

int y;

printf("\nGive any alphabetic character in lowercase: ");
while( (y = getchar()) != '\n' && y != EOF){
   continue;
}
printf("\n%c\n", toupper(y));

y el ajuste fue 'capturar' el carácter (n-1) justo antes de que se evalúe el condicional en el ciclo while, aquí está el código:

Código B

int y, x;

printf("\nGive any alphabetic character in lowercase: ");
while( (y = getchar()) != '\n' && y != EOF){
   x = y;
}
printf("\n%c\n", toupper(x));

La posible explicación es que para que el bucle while se rompa, tiene que asignar el valor '\ n' a la variable y, por lo que será el último valor asignado.

Si me perdí algo con la explicación, el código A o el código B, por favor dígame, apenas soy nuevo en c.

espero que ayude a alguien

unsigned char a=0;
if(kbhit()){
    a=getch();
    while(kbhit())
        getch();
}
cout<<hex<<(static_cast<unsigned int:->(a) & 0xFF)<<endl;

-o-

usar tal vez usar _getch_nolock().. ???

Otra solución aún no mencionada es usar: rebobinar (stdin);

Me sorprende que nadie haya mencionado esto:

scanf("%*[^\n]");

Corto, portátil y declarado en stdio.h

stdin = freopen(NULL,"r",stdin);

No se cuelga en un bucle infinito cuando no hay nada en stdin para limpiar como la siguiente línea bien conocida:

while ((c = getchar()) != '\n' && c != EOF) { }

Un poco caro, así que no lo use en un programa que necesite borrar repetidamente el búfer.

Robó a un compañero de trabajo :)

Prueba esto:

stdin->_IO_read_ptr = stdin->_IO_read_end;