Cross platform raw input handling in C/C++ for Linux and Windows

Question

For some of my terminal videogames I need to accept input in raw mode, which can be done in Windows by using the nonstandard function getch coming from the header conio.h but needs a little bit more effort for Linux and MacOS.

So I decided some time (more than a year) ago to write a small reusable header called cross_platform.hpp by reading some documentation and copypasting some code from various old forums, and the result is here and is reported below.

#include <cstdio>
#ifdef _WIN32
 #include <windows.h>
 #include <mmsystem.h>
 // #pragma comment(lib,"winmm.lib")
 #include <conio.h>
 void flushInput() {
 // Flush the input buffer (discard data not read yet)
 HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
 FlushConsoleInputBuffer(hInput);
 }
#elif __APPLE__
 #include <termios.h>
 #include <unistd.h>
 struct termios orig_termios;
 void term_echooff() {
 struct termios noecho;
 tcgetattr(0, &orig_termios);
 noecho = orig_termios;
 noecho.c_lflag &= ~ECHO;
 tcsetattr(0, TCSANOW, &noecho);
 }
 void flushInput() {
 // Flush stdin (discard data not read yet)
 tcflush(STDIN_FILENO, TCIFLUSH);
 }
#elif __linux__ 
 #include <unistd.h>
 #include <termios.h>
 char getch(void) {
 char buf = 0;
 struct termios old = {0};
 fflush(stdout);
 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");
 if(read(0, &buf, 1) < 0)
 perror("read()");
 old.c_lflag |= ICANON;
 old.c_lflag |= ECHO;
 if(tcsetattr(0, TCSADRAIN, &old) < 0)
 perror("tcsetattr ~ICANON");
 // printf("%c\n", buf);
 return buf;
 }
 void flushInput() {
 // Flush stdin (discard data not read yet)
 tcflush(STDIN_FILENO, TCIFLUSH);
 }
#endif

The need for a cross platform function, flushInput, which empties and flushes the input stream came later.

MacOS

I also have to say that the part for MacOS doesn't work at all, I know that I could use the following code...

system("stty raw -echo")

...but for some reason in the projects based on my library Sista it results in what seems to be echo mode, no matter what combination of raw and echo I try.

Double printing in Inomhus

As you can see instead of a rectangular grid the result is closer to the mess that you would expect in echo mode or when double printing some characters.

I am aware that in this community the submitted code should be already working: that's why I write this in a separate section and I don't include it in the questions, but an hint would be greatly appreciated if the issue is so obvious.

Here is the code without the MacOS related part.

#include <cstdio>
#ifdef _WIN32
 #include <windows.h>
 #include <mmsystem.h>
 // #pragma comment(lib,"winmm.lib")
 #include <conio.h>
 void flushInput() {
 // Flush the input buffer (discard data not read yet)
 HANDLE hInput = GetStdHandle(STD_INPUT_HANDLE);
 FlushConsoleInputBuffer(hInput);
 }
#elif __linux__ 
 #include <unistd.h>
 #include <termios.h>
 char getch(void) {
 char buf = 0;
 struct termios old = {0};
 fflush(stdout);
 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");
 if(read(0, &buf, 1) < 0)
 perror("read()");
 old.c_lflag |= ICANON;
 old.c_lflag |= ECHO;
 if(tcsetattr(0, TCSADRAIN, &old) < 0)
 perror("tcsetattr ~ICANON");
 // printf("%c\n", buf);
 return buf;
 }
 void flushInput() {
 // Flush stdin (discard data not read yet)
 tcflush(STDIN_FILENO, TCIFLUSH);
 }
#endif

Questions

1. Is there a smarter and highly compatible way of achieving this in Linux?
2. Are there some totally unnecessary parts in this "old" code that may have negative side effects (such as leaving the terminal unable to display (but not to accept) input if the program using the function crashes)?
3. Is there a "standard" way (so without conio.h's getch) to achieve this in Windows?

Also general learning tips on the topic of terminals are appreciated.

• Fe2O3: (Not a full answer) I wrote this code to muck around with UI interactivity (for Windows, only) and a bit of VT100 display manipulation. You're welcome to take a look at it. (Sometimes playing with retro can be fun and somewhat educational...)
• Fe2O3: "... leaving the terminal unable to display (but not to accept) input ..." Coders must train clients to fully and clearly express themselves. Coders must fully and clearly express themselves, too, setting a good example... I'm gonna guess you mean to say, "leaves the terminal in a bad state", or something similar. The verb "display" usually travels with "output", not "input".
• Chris: The single thing that appears to make this C++ code vs. C is #include <csdtio>. Is this really necessary vs. #include <stdio.h>?
• FLAK-ZOSO: @Fe2O3, the "display" is in fact about "output": this "bad state" of the terminal is a state in which I can input characters but I don't see the characters being printed in the terminal at all; however, if I press enter, the typed command gets executed. Thanks for the link, I will give a look to it.
• Fe2O3: @FLAK-ZOSO My pedantry was not called for. I apologise... The "jargon-y" word I'd suggest you use going forward is "echo"; "Input being echoed to the display"... I suggest "bad state" as there are myriad settings and methods that can depart from standard (expected) operation of i/o; 'echo' being but one of those... From memory, it's possible to 'turn off' driver mapping of CR to LF so that the user must type CTRL-J as the EOL character... Good luck!

Answer 1

Use an existing terminal I/O library

Instead of reinventing the wheel and writing all this non-portable, low-level I/O code by hand, consider looking for already existing libraries that take care of this for you.

In particular, consider using a curses library. This is basically a standard, platform-independent API to read raw input from, as well as move the cursor and write characters to a text console. There are several implementations of the curses API; for DOS/Windows PDCurses is a popular one, for all the other operating systems ncurses is the most widely used one.

There are also other libraries with different APIs. For example, if you want something that is better suited for C++, then look at FTXUI. I strongly recommend that you check out which is best suited for your needs.

• FLAK-ZOSO: Thank you for your answer, I didn't know PDCurses existed, this was helpful; I will try to see if this solves the MacOS problem as well.
• FLAK-ZOSO: Oh, wait. @G. Sliepen, may I ask? If I want to use ncurses, I need to do all I/O with ncurses functions? I cannot use the standard ones anymore until I do endwin()?
• G. Sliepen: @FLAK-ZOSO You can in principle still use standard I/O functions, but that would interfere with ncurses handling. Unless you really know what you're doing, it's best to stick with one way.

Answer 2

I finally found a solution to the MacOS issue, that I posted here. In the revisions you can see what I changed.

Edit to include canonical mode

What changed is that now non-canonical mode is set. This avoids the behaviour described in the question.

noecho.c_lflag &= ~(ECHO | ICANON);

I was already doing the same for Linux, but for some reason I had forgotten to do it for MacOS as well.

old.c_lflag &= ~ICANON;

This allows me not to depend on any other library and still handle the input with iostream or such.

---

The answer by @G. Sliepen is extremely useful, definitely more than mine for what concerns the general public of all those developers who don't use their own library. Thus I will keep it as the accepted answer despite this solution being the one I was actually looking for.