Interrupting program flow in C - c

Question

I've got a loop running that increments the value of a variable each iteration, and I want to be able to hit a key on the keyboard to stop the loop and report the final value of the variable. Thing is, I can't figure out how to do this in C. I feel stupid because it seems like I'm overlooking some really simple and easy way of doing this, but everything I try stops the loop until I hit a key on the keyboard, which is essentially the exact opposite of what I want.
Essentially what I want to do is something like this:
while (key is not pressed)
increment value
print final value
Does that make sense? Anyways, any tips on how to do this in C?

Answer 1

If you are trying to read a single character at a time (without pressing enter) from a terminal in linux then you will need to set the terminal for un-buffered input.
See this example:
Non buffered getc(3) under GNU/Linux

Answer 2

If you are permitted to specify what is pressed and you are on a POSIX.1-compliant system, you could set up a signal handler to catch SIGINT (sent by Ctrl+C). Have your handler change the value of a variable such that you fall out of the while loop.
If you choose this approach, be careful. If an incorrect implementation results in an infinite loop and a caught SIGINT, you will not be able to terminate your program via Ctrl+C. You would need to use kill(1) to terminate your program in this case.

Answer 3

If you're working on windows, and are using MSVC, you might want getch() and kbhit(), something like so
#include <conio.h>
while( looping ) {
// do regular loop stuff
// check if a key is hit, w/o blocking, using kbhit()
if( kbhit() ) {
// only runs when user has hit a key
// so display stuff here,
// and wait for permission to resume with getch()
getch();
}
}

Answer 4

It depends on your platform. The C language doesn't define stuff like this.
Windows? linux? (gnome app? kde app? terminal?) something else?

Answer 5

This is one place where the C standard leaves programmers hanging out to dry. The most portable solution to this problem is to do your I/O using the curses library, which handles so-called "raw" keyboard input (which is what you want) plus a whole lot more. The learning curve is a little steep, but there are good tutorials, especially in the BSD programmers' documentation.

Answer 6

The function you are calling to read a character is blocking. If there is no character there you want it to return instead.
Magic search terms here are non-blocking and non/unbufferred input.

Answer 7

Why would counting in loop until somebody press the key make the sense?
You if you realy want something like than check the timings for like 10k iterrations.
Then make waiting in non blocking itteration whit sleep(). When you get the time you can use it to approximate what the "final value" is

Answer 8

Depending upon the system and how it works, you could try to use the select function with the STDIN as a file handle. You can set the time on the select statement to zero to poll to see if there is data or set it to a time to wait.
You can look at the link http://www.gnu.org/s/libc/manual/html_node/Waiting-for-I_002fO.html for an example of using the select statement with sockets.
I have modified that example to use STDIN as the file descriptor. The function will return a 0 if there is no pending input, 1 if there is pending input (i.e. someone hit a key on the keyboard of input), or -1 if there was an error of some nature
#include <errno.h>
#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/time.h>
int waitForKBInput(unsigned int seconds)
{
/* File descriptor set on which to wait */
fd_set set;
/* time structure which indicate the amount of time to
wait. 0 will perform a poll */
struct timeval timeout;
/* Initialize the file descriptor set. */
FD_ZERO (&set);
/* Use the Standard Input as the descriptor on which
to wait */
FD_SET (STDIN, &set);
/* Initialize the timeout data structure. */
timeout.tv_sec = seconds;
timeout.tv_usec = 0;
/* select returns 0 if timeout, 1 if input available, -1 if error. */
/* and is only waiting on the input selection */
return select (FD_SETSIZE,
&set, NULL, NULL,
&timeout));
}
I know this will not work on VMS system, as I tried this and they implemented the Select and STDIN differently so it would not work (had to use other means to detect keyboard input).
For Visual C/C++ could could use the function kbhit which would indicate if there is keyboard inputs to be read.

Answer 9

I will try to look not at the verbatim question that you are asking, but at your intent - apparently you want to present the result of computation, triggered by some user reaction.
Checking 'is the key pressed?' at each and every iteration is fairly wasteful - your CPU could spend all that time doing more useful things.
So, the best approach here is using signals, in my opinion - namely, SIGINT that is triggered when you hit "Ctrl-C". Here's a code that will print the value of the variable when you hit the Ctrl-C, and will exit after you do it three times:
#include <stdio.h>
#include <stdlib.h>
#include <signal.h>
long globalvar = 0;
int interrupts_before_exit = 3;
void ctrl_c_handler(int x) {
printf("Value of the variable: %ld\n", globalvar);
if(--interrupts_before_exit) {
printf("Press Ctrl-C %d more times to stop\n", interrupts_before_exit);
} else {
printf("Computation interrupted!\n");
exit(0);
}
}
int main(int argc, char *argv[]) {
struct sigaction act;
act.sa_handler = ctrl_c_handler;
sigemptyset(&act.sa_mask);
act.sa_flags = 0;
if(sigaction(SIGINT, &act, NULL) >= 0) {
while (1) {
/* The work happens here */
globalvar++;
}
}
exit(1);
}
You can pass the signals between the programs, so in fact you could fork the program that does the "work", and then the second program would lazily monitor the keyboard - and as soon as the key is pressed there it would send the signal to the first one, which would print the result.

Answer 10

Some people have mentioned blocking. In *nix environments you can try setting the standard input file descriptor to non-blocking mode. Here is an example:
/* testbrk
Test breaking an infinite loop with a keystroke.
Hit the <Enter> key to break this loop.
*/
/* Include block */
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
/*---testbrk main loop---*/
int main ( int argc , char ** argv )
{
/* Variables: file flags , return value , buffer */
int f ;
ssize_t r ;
char b ;
/*
Switch standard input to non-blocking mode:
-Get existing flags from the file descriptor
-Bitwise OR to activate non-blocking bit
-Apply new flags
*/
if ( f = fcntl( STDIN_FILENO , F_GETFL , 0 ) == -1 )
{
perror ( "fcntl F_GETFL" ) ;
exit ( EXIT_FAILURE ) ;
}
f |= O_NONBLOCK ;
if ( f = fcntl( STDIN_FILENO , F_SETFL , f ) == -1 )
{
perror ( "fcntl F_SETFL" ) ;
exit ( EXIT_FAILURE ) ;
}
/*
Infinite loop
-try reading from standard input directly via its file
descriptor , NOT the standard input stream
-if the number of bytes returned is > zero then break
-if bytes returned is -1 then check errno for EAGAIN,
meaning that read would block but the file is nonblocking
-if zero is returned then print message immediately
*/
while ( (r = read( STDIN_FILENO , &b , sizeof( b ) )) < 1 )
{
if ( r == -1 && errno != EAGAIN )
{
perror ( "read" ) ;
exit ( EXIT_FAILURE ) ;
}
fprintf ( stderr , "\nInfinite loop" ) ;
} /* inf loop */
/* Done */
printf ( "\n\nBroken loop\n\n" ) ;
exit ( EXIT_SUCCESS ) ;
} /* testbrk */