Is it possible to get arrow key input in C++ for navigation purposes?

Question

Ryan McCombe · Accepted Answer

Yes, it is possible to handle arrow key input in C++ for navigation purposes, but it requires some platform-specific code.

Arrow keys typically generate special key codes that we need to capture and interpret. Let's explore how to do this on both Windows and Unix-like systems.

Windows Implementation

On Windows, we can use the _getch() function from <conio.h> to capture arrow key input:

1#include <iostream>
2#include <conio.h>  // Windows-specific header
3
4int main(){
5  std::cout <<
6    "Use arrow keys to navigate:\n";
7
8  while (true) {
9    int dir = _getch();
10
11    // Special key indicator
12    if (dir == 0 || dir == 224) {
13      switch (_getch()) {
14      case 72:
15        std::cout << "Up ";
16        break;
17      case 80:
18        std::cout << "Down ";
19        break;
20      case 75:
21        std::cout << "Left ";
22        break;
23      case 77:
24        std::cout << "Right ";
25        break;
26      }
27    } else { break; }
28  }
29}

1Up Down Left Right

This Windows implementation uses _getch() to read key presses without echoing them to the console. Arrow keys generate two characters: a special key indicator (0 or 224) followed by the actual arrow key code.

Unix-like Systems Implementation

For Unix-like systems, we can use the termios.h header to put the terminal in raw mode and capture individual key presses:

1#include <iostream>
2#include <termios.h>
3#include <unistd.h>
4
5enum class Direction {
6  Up,
7  Down,
8  Left,
9  Right,
10  Unknown
11};
12
13termios orig_termios;
14
15void disableRawMode(){
16  tcsetattr(STDIN_FILENO, TCSAFLUSH,
17            &orig_termios);
18}
19
20void enableRawMode(){
21  tcgetattr(STDIN_FILENO, &orig_termios);
22  atexit(disableRawMode);
23  termios raw = orig_termios;
24  raw.c_lflag &= ~(ECHO | ICANON);
25  tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
26}
27
28Direction getArrowKeyInput(){
29  char c;
30  if (read(STDIN_FILENO, &c, 1) == 1) {
31    if (c == '\x1b') {
32      char seq[3];
33      if (read(STDIN_FILENO, &seq[0], 1) !=
34        1) return Direction::Unknown;
35      if (read(STDIN_FILENO, &seq[1], 1) !=
36        1) return Direction::Unknown;
37      if (seq[0] == '[') {
38        switch (seq[1]) {
39        case 'A':
40          return Direction::Up;
41        case 'B':
42          return Direction::Down;
43        case 'C':
44          return Direction::Right;
45        case 'D':
46          return Direction::Left;
47        }
48      }
49    }
50  }
51  return Direction::Unknown;
52}
53
54int main(){
55  enableRawMode();
56  std::cout <<
57    "Use arrow keys to navigate (press 'q' to "
58    "quit):\n";
59  char c;
60  while (read(STDIN_FILENO, &c, 1) == 1 && c !=
61    'q') {
62    Direction dir = getArrowKeyInput();
63    switch (dir) {
64    case Direction::Up:
65      std::cout << "Up ";
66      break;
67    case Direction::Down:
68      std::cout << "Down ";
69      break;
70    case Direction::Left:
71      std::cout << "Left ";
72      break;
73    case Direction::Right:
74      std::cout << "Right ";
75      break;
76    default:
77      break;
78    }
79  }
80}

1Up Down Left Right

This Unix-like implementation puts the terminal in raw mode to read individual key presses. Arrow keys generate a sequence of characters starting with the escape character ('\x1b').

Cross-platform Solution

To create a cross-platform solution, you can use conditional compilation:

1#include <iostream>
2
3#ifdef _WIN32
4#include <conio.h>
5#else
6#include <termios.h>
7#include <unistd.h>
8#endif
9
10enum class Direction {
11  Up,
12  Down,
13  Left,
14  Right,
15  Unknown
16};
17
18#ifndef _WIN32
19termios orig_termios;
20
21void disableRawMode() {
22  tcsetattr(STDIN_FILENO, TCSAFLUSH, &orig_termios);
23}
24
25void enableRawMode() {
26  tcgetattr(STDIN_FILENO, &orig_termios);
27  atexit(disableRawMode);
28  termios raw = orig_termios;
29  raw.c_lflag &= ~(ECHO | ICANON);
30  tcsetattr(STDIN_FILENO, TCSAFLUSH, &raw);
31}
32#endif
33
34Direction getArrowKeyInput(){
35#ifdef _WIN32
36  switch (_getch()) {
37  case 72:
38    return Direction::Up;
39  case 80:
40    return Direction::Down;
41  case 75:
42    return Direction::Left;
43  case 77:
44    return Direction::Right;
45  default:
46    return Direction::Unknown;
47  }
48#else
49  char c;
50  if (read(STDIN_FILENO, &c, 1) == 1) {
51    if (c == '\x1b') {
52      char seq[3];
53      if (read(STDIN_FILENO, &seq[0], 1) != 1)
54        return Direction::Unknown;
55      if (read(STDIN_FILENO, &seq[1], 1) != 1)
56        return Direction::Unknown;
57      if (seq[0] == '[') {
58        switch (seq[1]) {
59          case 'A':
60            return Direction::Up;
61          case 'B':
62            return Direction::Down;
63          case 'C':
64            return Direction::Right;
65          case 'D':
66            return Direction::Left;
67        }
68      }
69    }
70  }
71#endif
72  return Direction::Unknown;
73}
74
75int main(){
76#ifndef _WIN32
77  enableRawMode();
78#endif
79  std::cout <<
80    "Use arrow keys to navigate (press 'q' to "
81    "quit):\n";
82  int ch;
83  while (true) {
84#ifdef _WIN32
85    ch = _getch();
86#else
87    read(STDIN_FILENO, &ch, 1);
88#endif
89    if (ch == 'q') break;
90    if (ch != 0 && ch != 224) continue;
91    Direction dir = getArrowKeyInput();
92    switch (dir) {
93    case Direction::Up:
94      std::cout << "Up\n";
95      break;
96    case Direction::Down:
97      std::cout << "Down\n";
98      break;
99    case Direction::Left:
100      std::cout << "Left\n";
101      break;
102    case Direction::Right:
103      std::cout << "Right\n";
104      break;
105    default:
106      break;
107    }
108  }
109}

1Up Down Left Right

This cross-platform solution uses conditional compilation to choose the appropriate implementation based on the target platform. It provides a consistent interface for handling arrow key input across different operating systems.

Remember that this low-level input handling can make your program less portable and more complex. For more advanced applications, consider using cross-platform libraries like ncurses or SDL that provide higher-level abstractions for keyboard input and terminal control.

User Input in the Terminal

Handling Arrow Key Input in C++

Windows Implementation

Unix-like Systems Implementation

Cross-platform Solution

User Input in the Terminal

Intro to C++ Programming

Questions & Answers