CLI in C++: cin and Ctrl+C - c++

Question

I have an infinite loop to implement a custom CLI, as follows
while (1) {
getline(cin, _input);
_parse_cmd(_input);
}
I created a signal handler as follows:
BOOL WINAPI _consoleSignalHandler(DWORD CEvent) {
char mesg[128];
switch (CEvent)
{
case CTRL_SHUTDOWN_EVENT:
case CTRL_LOGOFF_EVENT:
case CTRL_CLOSE_EVENT:
case CTRL_BREAK_EVENT:
if (_CLI_instance) {
cout << "Close Signal" << endl;
}
break;
case CTRL_C_EVENT:
cout << "Ctrl + C to be implemented" << endl;
break;
default:
return FALSE;
break;
}
return TRUE;
}
With this configuration, when I hit CTRL+C, the CLI prints the message "Ctrl + C to be implemented"and never waits for user input again. How can I solve this?
NOTE: parse_cmd is a generic command parser that executes simple actions

Answer 1

Edit :
Your problem is that in C++, when the getline function is interrupted, you have to manually clear the error state before next call. It is enough in your loop to write :
while (1) {
getline(cin, _input);
if (cin.fail() || cin.eof()) {
cin.clear(); // reset cin state
}
_parse_cmd(_input);
}
But beware: as you also filter Ctrl-Break, you loop could be hard to stop ...
TL/DR : Below are my first steps to this simple solution first in C idiom, next in C++ one, that only filter Ctrl-C and are killed on Ctrl-Break.
You can obtain easily the Ctrl-C interception with the signal function.
Here is an example of usage :
#include <stdio.h>
#include <signal.h>
void ctrl_c(int sig) {
fprintf(stderr, "Ctrl-C caught\n");
signal(sig, ctrl_c); /* re-installs handler */
}
int main() {
char buf[256];
void (*old)(int);
old = signal(SIGINT, ctrl_c); /* installs handler */
for (;;) {
if (fgets(buf, sizeof(buf), stdin) != NULL) {
printf("Got : %s", buf);
}
}
signal(SIGINT, old); /* restore initial handler */
return 0;
}
Ctrl-C is intercepted, Ctrl-Break kills the program.
Edit :
Old C version was straightforward. In C++ you have to clear flags in cin if getline was interrupted :
#include <iostream>
#include <string>
#include <csignal>
using namespace std;
void ctrl_c(int sig) {
cerr << "Ctrl-C caught" << endl;
signal(sig, ctrl_c); // re-installs handler
}
int main() {
string buf;
void (*old)(int);
old = signal(SIGINT, ctrl_c); // installs handler
for (;;) {
getline(cin, buf);
if (cin.fail() || cin.eof()) {
cin.clear(); // reset cin state
}
else {
cout << "Got" << buf << endl;
}
}
signal(SIGINT, old); // restore initial handler
return 0;
}
It's now correct C++ even if I do not use the Microsoft specific SetConsoleCtrlHandler. IMHO signal usage if more simple if only Ctrl-C has to be caught.