¿Cómo simular "Presione cualquier tecla para continuar?"

Estoy tratando de escribir un programa en C ++ en el que cuando el usuario ingrese cualquier carácter desde el teclado, debería moverse a la siguiente línea de código.

Aquí está mi código:

char c;

cin>>c;

cout<<"Something"<<endl;

pero esto no funciona, porque solo se mueve a la siguiente línea cuando ingreso algún carácter y luego presiono ENTER.

O

Si uso esto

cin.get() or cin.get(c)

se mueve a la siguiente línea de instrucción cuando presiono Enter.

Pero quería que se moviera a la siguiente línea en cualquier tecla presionada en el teclado, ¿cómo se puede hacer esto?

En Windows:

system("pause");

y en Mac y Linux:

system("read");

mostrará "Presione cualquier tecla para continuar ..." y obviamente, espere a que se presione cualquier tecla. Espero que eso sea lo que quisiste decir

Si está en Windows, puede usar el kbhit()que forma parte de la biblioteca de tiempo de ejecución de Microsoft. Si está en Linux, puede implementarlo kbhitasí ( fuente ):

#include <stdio.h>
#include <termios.h>
#include <unistd.h>
#include <fcntl.h>

int kbhit(void)
{
  struct termios oldt, newt;
  int ch;
  int oldf;

  tcgetattr(STDIN_FILENO, &oldt);
  newt = oldt;
  newt.c_lflag &= ~(ICANON | ECHO);
  tcsetattr(STDIN_FILENO, TCSANOW, &newt);
  oldf = fcntl(STDIN_FILENO, F_GETFL, 0);
  fcntl(STDIN_FILENO, F_SETFL, oldf | O_NONBLOCK);

  ch = getchar();

  tcsetattr(STDIN_FILENO, TCSANOW, &oldt);
  fcntl(STDIN_FILENO, F_SETFL, oldf);

  if(ch != EOF)
  {
    ungetc(ch, stdin);
    return 1;
  }

  return 0;
}

Actualización: la función anterior funciona en OS X (al menos, en OS X 10.5.8 - Leopard, por lo que esperaría que funcione en versiones más recientes de OS X). Esta esencia se puede guardar kbhit.cy compilar tanto en Linux como en OS X con

gcc -o kbhit kbhit.c

Cuando se ejecuta con

./kbhit

Le solicita que presione una tecla y sale cuando presiona una tecla (no se limita a Enter o teclas imprimibles).

@Johnsyweb : explique lo que quiere decir con "respuesta canónica detallada" y "todas las preocupaciones". Además, vuelva a ser "multiplataforma": con esta implementación kbhit(), puede tener la misma funcionalidad en un programa C ++ en Linux / Unix / OS X / Windows. ¿A qué otras plataformas se está refiriendo?

Actualización adicional para @Johnsyweb: las aplicaciones C ++ no viven en un entorno C ++ herméticamente sellado. Una gran razón del éxito de C ++ es la interoperabilidad con C. Todas las plataformas principales se implementan con interfaces C (incluso si la implementación interna usa C ++), por lo que su discurso de "legado" parece fuera de lugar. Además, como estamos hablando de una sola función, ¿por qué necesita C ++ para esto ("C con clases")? Como señalé, puede escribir en C ++ y acceder a esta funcionalidad fácilmente, y es poco probable que a los usuarios de su aplicación les importe cómo la implementó.

No existe una solución completamente portátil.

La pregunta 19.1 de las preguntas frecuentes de comp.lang.c cubre esto con cierta profundidad, con soluciones para Windows, sistemas similares a Unix e incluso MS-DOS y VMS.

Un resumen rápido e incompleto:

• Puede utilizar la cursesbiblioteca; llamada cbreak()seguida de getch()(no confundir con la getch()función específica de Windows ). Tenga en cuenta que cursesgeneralmente toma el control del terminal, por lo que es probable que esto sea excesivo.
• Es posible que pueda utilizar ioctl()para manipular la configuración del terminal.
• En sistemas compatibles con POSIX tcgetattr()y tcsetattr()puede ser una mejor solución.
• En Unix, puede utilizar system()para invocar el sttycomando.
• En MS-DOS, puede usar getch()o getche().
• En VMS (ahora llamado OpenVMS), las SMG$rutinas de Gestión de pantalla ( ) pueden funcionar.

Todas estas soluciones C deberían funcionar igualmente bien en C ++; No conozco ninguna solución específica de C ++.

Para lograr esta funcionalidad, puede usar la biblioteca ncurses que se implementó tanto en Windows como en Linux (y MacOS, hasta donde yo sé).

En Windows, este programa corto logra el objetivo: getchpausa la consola hasta que se presiona una tecla ( https://www.geeksforgeeks.org/difference-getchar-getch-getc-getche/ )

#include<iostream.h>
#include<conio.h>

using namespace std;

void  check()
{
    char chk; int j;
    cout<<"\n\nPress any key to continue...";
    chk=getch();
    j=chk;
    for(int i=1;i<=256;i++)
      if(i==j) break;
    clrscr();
}

void main()
{
    clrscr();
    check();
    cout<<"\n\nIt works!";
    getch();
}

Cabe señalar que getch no forma parte de la biblioteca estándar.

Investigué lo que estás tratando de lograr, porque recuerdo que quería hacer lo mismo. Inspirado por Vinay , escribí algo que funciona para mí y lo entiendo. Pero no soy un experto, así que tenga cuidado.

No sé cómo sabe Vinay que estás usando Mac OS X. Pero debería funcionar así con la mayoría de los sistemas operativos tipo Unix. Realmente útil como recurso es opengroup.org

Asegúrese de vaciar el búfer antes de usar la función.

#include <stdio.h>
#include <termios.h>        //termios, TCSANOW, ECHO, ICANON
#include <unistd.h>     //STDIN_FILENO


void pressKey()
{
    //the struct termios stores all kinds of flags which can manipulate the I/O Interface
    //I have an old one to save the old settings and a new 
    static struct termios oldt, newt;
    printf("Press key to continue....\n");

    //tcgetattr gets the parameters of the current terminal
    //STDIN_FILENO will tell tcgetattr that it should write the settings
    // of stdin to oldt
    tcgetattr( STDIN_FILENO, &oldt);
    //now the settings will be copied 
    newt = oldt;

    //two of the c_lflag will be turned off
    //ECHO which is responsible for displaying the input of the user in the terminal
    //ICANON is the essential one! Normally this takes care that one line at a time will be processed
    //that means it will return if it sees a "\n" or an EOF or an EOL
    newt.c_lflag &= ~(ICANON | ECHO );      

    //Those new settings will be set to STDIN
    //TCSANOW tells tcsetattr to change attributes immediately. 
    tcsetattr( STDIN_FILENO, TCSANOW, &newt);

    //now the char wil be requested
    getchar();

    //the old settings will be written back to STDIN
    tcsetattr( STDIN_FILENO, TCSANOW, &oldt);

}


int main(void)
{
  pressKey();
  printf("END\n");
  return 0;
}

O_NONBLOCK también parece ser una bandera importante, pero no cambió nada para mí.

Agradezco que personas con un conocimiento más profundo comenten sobre esto y den algún consejo.

Puede utilizar la función _getch específica de Microsoft :

#include <iostream>
#include <conio.h>
// ...
// ...
// ...
cout << "Press any key to continue..." << endl;
_getch();
cout << "Something" << endl;

Esto funciona en una plataforma Windows: usa los registros del microprocesador directamente y se puede usar para verificar la pulsación de teclas o el botón del mouse

    #include<stdio.h>
    #include<conio.h>
    #include<dos.h>
    void main()
    {
     clrscr();
     union REGS in,out;
     in.h.ah=0x00;
     printf("Press any key : ");

     int86(0x16,&in,&out);
     printf("Ascii : %d\n",out.h.al);
     char ch = out.h.al;
     printf("Charcter Pressed : %c",&ch);
     printf("Scan code : %d",out.h.ah);
     getch();
    }

Si usa Visual Studio 2012 o una versión anterior, use la getch()función; si usa Visual Studio 2013 o una versión más reciente, use _getch(). Tendrás que usar #include <conio.h>. Ejemplo:

#include <iostream>
#include <conio.h>

int main()
{
   std::cout << "Press any key to continue. . .\n";
   _getch(); //Or getch()
}

Puede utilizar la rutina getchar .

Desde el enlace de arriba:

/* getchar example : typewriter */
#include <stdio.h>

int main ()
{
  char c;
  puts ("Enter text. Include a dot ('.') in a sentence to exit:");
  do {
    c=getchar();
    putchar (c);
  } while (c != '.');
  return 0;
}

También puede usar getch () de conio.h. Así:

...includes, defines etc
void main()
{
//operator
getch(); //now this function is waiting for any key press. When you have pressed its     just     //finish and next line of code will be called
}

Entonces, debido a que UNIX no tiene conio.h, podemos simular getch () mediante este código (pero este código ya está escrito por Vinary, mi error):

#include <stdio.h>
#include <termios.h>
#include <unistd.h>

int mygetch( ) {
  struct termios oldt,
             newt;
  int            ch;
  tcgetattr( STDIN_FILENO, &oldt );
  newt = oldt;
  newt.c_lflag &= ~( ICANON | ECHO );
  tcsetattr( STDIN_FILENO, TCSANOW, &newt );
  ch = getchar();
  tcsetattr( STDIN_FILENO, TCSANOW, &oldt );
  return ch;
}

Si busca la función kbhit () en MSDN ahora, dice que la función está obsoleta. Utilice _kbhit () en su lugar.

#include <conio.h>
int main()
{
    _kbhit();
    return 0;
}

#include <iostream>
using namespace std;

int main () {
    bool boolean;
    boolean = true;

    if (boolean == true) {

        cout << "press any key to continue";
        cin >> boolean;

    }
    return 0;
}

Solo usa el system("pause");comando.

Todas las demás respuestas complican el problema.