descargar - c++ manual

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

Question

Intento escribir un programa en C ++ en el cual, 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 pasa 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 pasara a la siguiente línea con cualquier tecla presionada en el teclado, ¿cómo se puede hacer esto?

Answer 1

En Windows:

system("pause");

y en Mac y Linux:

system("read");

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

Answer 2

Esto es muy simple . Hice un programa y funciona perfecto. Aquí está el programa.

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

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/nSee, Its Working....Have a Good day";
    getch();
}

Answer 3

Investigué lo que intentas lograr, porque recuerdo que quería hacer lo mismo. Inspirado por , escribí algo que me funciona y que entiendo. Pero no soy un experto, así que ten cuidado.

No sé cómo Vinay sabe que estás usando Mac OS X. Pero debería funcionar más o menos así con el sistema operativo tipo Unix. Realmente útil como recurso es opengroup.org

Asegúrese de enjuagar el buffer 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 parece ser una bandera importante, pero no cambió nada para mí.

Aprecio que las personas con un conocimiento más profundo lo comenten y den algunos consejos.

Answer 4

No hay una solución completamente portátil.

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

Un resumen rápido e incompleto:

• Puede usar la biblioteca de curses ; call cbreak() seguido de getch() (que no debe confundirse con la función getch() específica de Windows). Tenga en cuenta que las curses generalmente toman el control del terminal, por lo que es probable que sea excesivo.
• Es posible que pueda usar ioctl() para manipular la configuración del terminal.
• En los sistemas que cumplen con POSIX, tcgetattr() y tcsetattr() pueden ser una mejor solución.
• En Unix, puede usar system() para invocar el comando stty .
• En MS-DOS, puede usar getch() o getche() .
• En VMS (ahora se llama OpenVMS), las rutinas de Administración de pantallas ( SMG$ ) pueden ser útiles.

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

Answer 5

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

Answer 6

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

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

Answer 7

Puede usar la variable Scanner y usar el método HasNext (). Luego divídalo y salga usando una función exit ();

import java.util.Scanner;

    public class exit_onClick {
        public static int exit()
        {
            return 0;
        }
        public static void main(String[] args) {
            Scanner scan = new Scanner(System.in);
            System.out.println("Press Any Key to EXIT....");
            int c=0;
            while(scan.hasNext())
            {
                c++;
                if(c==1)
                    break;
            }
            exit();
        }

    }

Answer 8

Puedes usar la rutina getchar .

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

Answer 9

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

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

Answer 10

Si está en Windows, puede usar kbhit() que es parte de la biblioteca de tiempo de ejecución de Microsoft. Si estás en Linux, puedes implementar kbhit así ( 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;
}

Actualización: la función anterior funciona en OS X (al menos, en OS X 10.5.8 - Leopard, por lo que espero que funcione en versiones más recientes de OS X). Esta gist se puede guardar como kbhit.c y compilarse en Linux y OS X con

gcc -o kbhit kbhit.c

Cuando se ejecuta con

./kbhit

Le solicita una pulsación de tecla y sale cuando pulsa una tecla (no está limitado a Intro o teclas imprimibles).

@Johnsyweb - por favor, elabore lo que quiere decir con "respuesta canónica detallada" y "todas las preocupaciones". Además, re "multiplataforma": con esta implementación de kbhit() puede tener la misma funcionalidad en un programa C ++ en Linux / Unix / OS X / Windows, ¿a qué otras plataformas podría estar refiriéndose?

Actualización adicional para @Johnsyweb: las aplicaciones C ++ no viven en un entorno C ++ herméticamente sellado. Una gran razón para el é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 charla de "legado" parece fuera de lugar. Además, como estamos hablando de una función única, ¿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ó.

Answer 11

Si está usando Visual Studio 2012 o una versión anterior, use la función "getch ()", si está usando Visual Studio 2013 o una versión posterior, use "_getch ()". Deberá usar "#include <conio.h>". Ejemplo:

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

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

Answer 12

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

Todas las demás respuestas complican el problema.

Answer 13

También puedes usar getch () desde conio.h. Solo 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, dado 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;
}

Answer 14

Esto funciona en una plataforma de Windows: utiliza los registros del microprocesador directamente y se puede usar para verificar la pulsación de la tecla 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();
    }

Answer 15

#include <iostream>
using namespace std;

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

    if (boolean == true) {

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

    }
    return 0;
}