How can I interrupt a loop with a key press in C++ on OS X?

Question

I would like to do the following in a command-line application on OS X:

while (true) {
    // do some task
    if (user_has_pressed('x')) {
        // break out of the loop and do something different
    }
}

For clarity, I don't want the program to block waiting for user input. I'm running a numerical simulation that takes many hours to run, and I want to press a key to print detailed statistics on its progress, or interrupt it and change parameters, etc.

There are some existing similar questions, but the answers either suggest a windows-only getch function, or they switch the terminal into a different input mode. I don't want to do that, because I need to retain the ability to interrupt with ctrl-c without messing up the terminal.

I don't want to build a Cocoa application, and I don't care about being cross-platform. I'm just looking for the simplest quick-and-dirty way to do it in a command line app that will only ever be run on my own machine.

I guess one option is to use ncurses. From a brief bit of reading it seems like a heavier option than I'd like - but if somebody would post a simple minimal example that accomplishes the above task that would be really helpful.

Answer 1

Are you looking for the following behavior?

   #include <pthread.h>
   #include <iostream>

   static volatile bool keep_running = true;

   static void* userInput_thread(void*)
   {
       while(keep_running) {
           if (std::cin.get() == 'q')
           {
               //! desired user input 'q' received
               keep_running = false;
           }
       }
   }

   int main()
   {
      pthread_t tId;
      (void) pthread_create(&tId, 0, userInput_thread, 0);

      while ( keep_running )
      {
         //! this will run until you press 'q'
      }

      (void) pthread_join(tId, NULL);

      return 0;
   }

Answer 2

The basic idea is to use poll, but the terminal would normally wait for an enter key before it sends the key press to stdin. So we need disable the canonial mode first.

#include <poll.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
#include <string.h>
#include <termios.h>
#include <iostream>

void disable_canonical(){
    struct termios old = {0};
    if (tcgetattr(0, &old) < 0)
        perror("tcsetattr()");
    old.c_lflag &= ~ICANON;
    old.c_lflag &= ~ECHO;
    old.c_cc[VMIN] = 1;
    old.c_cc[VTIME] = 0;
    if (tcsetattr(0, TCSANOW, &old) < 0)
        perror("tcsetattr ICANON");
}
void enable_canonical(){
    struct termios old = {0};
    if (tcgetattr(0, &old) < 0)
        perror("tcsetattr()");
    old.c_lflag |= ICANON;
    old.c_lflag |= ECHO;
    old.c_cc[VMIN] = 1;
    old.c_cc[VTIME] = 0;
    if (tcsetattr(0, TCSANOW, &old) < 0)
        perror("tcsetattr ICANON");
}
bool key_pressed(char c){
    struct pollfd fds[1];
    fds[0].fd = 0;
    fds[0].events = POLLIN;
    fds[0].revents = 0;
    int r = poll(fds, 1, 1);
    if(r > 0){
        if(fds[0].revents & POLLIN || fds[0].revents & POLLRDBAND || fds[0].revents & POLLRDNORM){
            char buffer[1024];
            memset(buffer, 0, sizeof(buffer));
            int n = read(0, buffer, sizeof(buffer) -1);
            for(int i = 0; i < n; ++i){
                if(buffer[i] == c){
                    return true;
                }
            }
        }
    }
    return false;
}

int main(){
    disable_canonical();
    while(true){
        if(key_pressed('x')){
            break;
        }
        usleep(500);
        //std::cout << "looping...\n";
    }
    enable_canonical();
}

P.S. the tcsetattr code is borrowed from https://stackoverflow.com/a/912796/573789

Answer 3

I believe what you are looking for is how to break out of the loop but keep the program still running.

One of the solution for your problem can be the use of the goto C++ keyword. Please look at the following code:

while(true)
{
   char pressKeyToQuit = 'q';
   cin >> pressKeyToQuit;

   if(pressKeyToQuit == 'q')
   {
       goto getOffTheLoop; //to do something different
   }

   getOffTheLoop:
 //do something different
  cout << "Processing!\n";

}

Hope I helped! :D

Answer 4

The following can help:

#include <iostream>
using namespace std;

int main() {
    while (cin.get() != 'x') {
        cout << "I am running." << endl;
    }
    return 0;
}

But if you don't want your program to stop, use a thread as mentioned in this answer.

Answer 5

You can use the POSIX signals:

#include <signal.h>

static volatile bool keep_continue = true;

int main()
{
    signal(SIGINT, [](int) { keep_continue = false; });

    while (keep_continue)
    {
        // run until you press ctrl-c
    }
}

Answer 6

As a hack( dirty but fast ) solution consider a file that interrupts execution of the loop...

#include <fstream>
#include <iostream>
#include <unistd.h>
int main()
{
    while( 1 )
    {

        std::cout << "start" << std::endl;

        std::ifstream ifs( "stop" );

        if( ifs.good() )
        {
            std::cout << "exit" << std::endl;
            ifs.close();
            break;
        }
        ifs.close();
        ifs.open( "pause" );
        while( ifs.good() )
        {
            usleep( 100 );
            ifs.close();
            ifs.open( "pause" );
        }

        std::cout << "end" << std::endl;
    }
}

For the given program above, to pause it, create a pause file in the same folder as your executable

touch pause

or

> pause (in mac os)

To unpause,

rm pause

To stop,

> stop (don't forget to rm stop before you run executable again)

Use aliases to reduce number of chars to type

alias p='touch ..path_to_executable../pause'

alias s='touch ..path_to_executable../stop'

alias run='if [ -f "..path_to_executable../pause"] ; then rm "..path_to_executable../pause" fi;if [ -f "..path_to_executable../stop"] ; then rm "..path_to_executable../stop" fi; ..path_to_executable../..executable..'

Answer 7

Have you tried the non-blocking read?

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

int main()
{
    int flags = fcntl(0, F_GETFL, 0); // we get the current flags applying on input file descriptor
    fcntl(0, F_SETFL, flags | O_NONBLOCK); // add the non-blocking flag to input file descriptor

    while (read(0, NULL, 0u) < 0)
    {
        // run until you press ENTER key
    }
}

The program exits when you press ENTER. It works on Debian 9, but I have no OS X within easy reach to test on it.

Answer 8

I think you should see the article on - http://cc.byexamples.com/2007/04/08/non-blocking-user-input-in-loop-without-ncurses/

I would have commented this, but I don't have enough reputation.