Comment simuler "Appuyez sur n'importe quelle touche pour continuer?"

J'essaie d'écrire un programme C ++ dans lequel, lorsque l'utilisateur entre un caractère à partir du clavier et qu'il doit passer à la ligne de code suivante.

Voici mon code:

char c;

cin>>c;

cout<<"Something"<<endl;

mais cela ne fonctionne pas, car il ne passe à la ligne suivante que lorsque j'entre un caractère et que j'appuie sur ENTRÉE.

OU

Si j'utilise ceci

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

il passe à la ligne d'instruction suivante lorsque j'appuie sur Entrée.

Mais je voulais qu'il passe à la ligne suivante sur n'importe quelle touche du clavier, comment cela peut-il être fait?

Sous Windows:

system("pause");

et sur Mac et Linux:

system("read");

affichera "Appuyez sur n'importe quelle touche pour continuer ..." et, évidemment, attendez qu'une touche soit enfoncée. J'espère que c'est ce que tu voulais dire

Si vous êtes sous Windows, vous pouvez utiliser kbhit()ce qui fait partie de la bibliothèque d'exécution Microsoft. Si vous êtes sous Linux, vous pouvez implémenter kbhitainsi ( source ):

#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;
}

Mise à jour: La fonction ci-dessus fonctionne sur OS X (au moins, sur OS X 10.5.8 - Leopard, donc je m'attendrais à ce qu'elle fonctionne sur les versions plus récentes d'OS X). Cet élément essentiel peut être enregistré kbhit.cet compilé sous Linux et OS X avec

gcc -o kbhit kbhit.c

Lorsqu'il est exécuté avec

./kbhit

Il vous invite à appuyer sur une touche et se termine lorsque vous appuyez sur une touche (non limité à Entrée ou aux touches imprimables).

@Johnsyweb - veuillez préciser ce que vous entendez par «réponse canonique détaillée» et «toutes les préoccupations». Aussi, re "multi-plateforme": Avec cette implémentation de, kbhit()vous pouvez avoir les mêmes fonctionnalités dans un programme C ++ sous Linux / Unix / OS X / Windows - à quelles autres plates-formes pourriez-vous faire référence?

Mise à jour supplémentaire pour @Johnsyweb: les applications C ++ ne vivent pas dans un environnement C ++ hermétiquement fermé. Une des principales raisons du succès de C ++ est l'interopérabilité avec C. Toutes les plates-formes traditionnelles sont implémentées avec des interfaces C (même si l'implémentation interne utilise C ++), donc votre discours sur "l'héritage" semble déplacé. De plus, comme nous parlons d'une seule fonction, pourquoi avez-vous besoin de C ++ pour cela ("C avec classes")? Comme je l'ai souligné, vous pouvez écrire en C ++ et accéder facilement à cette fonctionnalité, et il est peu probable que les utilisateurs de votre application se soucient de la façon dont vous l' avez implémentée.

Il n'y a pas de solution totalement portable.

La question 19.1 de la FAQ comp.lang.c couvre cela en profondeur, avec des solutions pour Windows, les systèmes de type Unix, et même MS-DOS et VMS.

Un résumé rapide et incomplet:

• Vous pouvez utiliser la cursesbibliothèque; appel cbreak()suivi de getch()(à ne pas confondre avec la getch()fonction spécifique à Windows ). Notez que cursesprend généralement le contrôle du terminal, il est donc probable que ce soit excessif.
• Vous pourrez peut-être utiliser ioctl()pour manipuler les paramètres du terminal.
• Sur les systèmes compatibles POSIX, tcgetattr()et tcsetattr()peut être une meilleure solution.
• Sous Unix, vous pouvez utiliser system()pour appeler la sttycommande.
• Sous MS-DOS, vous pouvez utiliser getch()ou getche().
• Sur VMS (maintenant appelé OpenVMS), les SMG$routines de gestion d'écran ( ) peuvent faire l'affaire.

Toutes ces solutions C devraient fonctionner aussi bien en C ++; Je ne connais aucune solution spécifique à C ++.

Pour obtenir cette fonctionnalité, vous pouvez utiliser la bibliothèque ncurses qui a été implémentée à la fois sur Windows et Linux (et MacOS pour autant que je sache).

Sous Windows, ce programme court atteint l'objectif: getchmet la console en pause jusqu'à ce qu'une touche soit enfoncée ( 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();
}

Il est à noter que getch ne fait pas partie de la bibliothèque standard.

J'ai regardé ce que vous essayez de réaliser, car je me souviens que je voulais faire la même chose. Inspiré par Vinay, j'ai écrit quelque chose qui fonctionne pour moi et je comprends en quelque sorte. Mais je ne suis pas un expert, alors soyez prudent.

Je ne sais pas comment Vinay sait que vous utilisez Mac OS X. Mais cela devrait fonctionner un peu comme ça avec la plupart des systèmes d'exploitation de type Unix. Opengroup.org est vraiment utile en tant que ressource

Assurez-vous de vider le tampon avant d'utiliser la fonction.

#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 semble également être un indicateur important, mais cela n'a rien changé pour moi.

J'apprécie que des personnes ayant des connaissances plus approfondies puissent commenter cela et donner des conseils.

Vous pouvez utiliser la fonction _getch spécifique à Microsoft :

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

Cela fonctionne sur une plate-forme Windows: il utilise directement les registres du microprocesseur et peut être utilisé pour vérifier la pression sur une touche ou le bouton de la souris

    #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 vous utilisez Visual Studio 2012 ou une version antérieure, utilisez la getch()fonction, si vous utilisez Visual Studio 2013 ou une version plus récente, utilisez _getch(). Vous devrez utiliser #include <conio.h>. Exemple:

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

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

Vous pouvez utiliser la routine getchar .

À partir du lien ci-dessus:

/* 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;
}

Vous pouvez également utiliser getch () depuis conio.h. Juste comme ça:

...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
}

Donc, comme UNIX n'a ​​pas conio.h, nous pouvons simuler getch () par ce code (mais ce code déjà écrit par Vinary, mon échec):

#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 vous recherchez la fonction kbhit () sur MSDN maintenant, cela indique que la fonction est obsolète. Utilisez plutôt _kbhit ().

#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;
}

Utilisez simplement la system("pause");commande.

Toutes les autres réponses compliquent le problème.