Linux终端TUI开发：ncurses库入门与实践

大JoeJoe

1. 认识TUI与ncurses

在Linux环境下工作时，我们经常需要与终端打交道。大多数人熟悉的可能是命令行界面（CLI），但还有一种更强大的交互方式——文本用户界面（TUI）。TUI不同于纯文本输出，它能够在终端中创建窗口、菜单、按钮等交互元素，而这一切的核心就是ncurses库。

我第一次接触ncurses是在开发一个需要在终端中显示实时数据的项目时。当时我需要一个能在终端中动态更新的界面，而不是简单的命令行输出。经过调研，发现ncurses正是解决这个问题的完美工具。

ncurses（new curses）是curses库的GNU实现，它提供了一套API，允许开发者在终端中创建基于文本的图形用户界面。与GUI不同，TUI不需要图形服务器，可以在任何终端环境中运行，这使得它在服务器管理、嵌入式系统等场景中特别有用。

提示：虽然现代系统大多使用图形界面，但在远程管理、资源受限环境或需要快速响应的场景中，TUI往往比GUI更高效。

2. 搭建ncurses开发环境

2.1 安装ncurses开发库

在开始使用ncurses之前，我们需要确保系统已经安装了相应的开发库。在基于Debian的系统（如Ubuntu）上，安装非常简单：

bash复制sudo apt update
sudo apt install libncurses5-dev -y

这个命令会安装ncurses的开发库和头文件。安装完成后，你可以通过以下命令验证安装是否成功：

bash复制dpkg -l | grep ncurses

2.2 编译ncurses程序

编译ncurses程序时，需要链接ncurses库。一个典型的编译命令如下：

bash复制gcc your_program.c -o your_program -Wall -lncurses

这里有几个关键点需要注意：

-Wall：启用所有警告，帮助发现潜在问题
-lncurses：链接ncurses库，这是必须的

如果你使用的是C++，可能需要使用-lncursesw（宽字符版本）或-lncurses++（C++绑定）。

3. ncurses基础编程

3.1 最简单的ncurses程序

让我们从一个最简单的例子开始，了解ncurses的基本结构：

c复制#include <ncurses.h>

int main() {
    initscr();          // 初始化ncurses模式
    printw("Hello, World!"); // 在虚拟屏幕上打印字符串
    refresh();          // 将虚拟屏幕内容刷新到物理屏幕
    getch();            // 等待用户按键
    endwin();           // 结束ncurses模式
    return 0;
}

这个程序展示了ncurses的基本工作流程：

initscr()：初始化ncurses环境
printw()：在虚拟屏幕上输出内容
refresh()：将虚拟屏幕内容刷新到实际屏幕
getch()：等待用户输入
endwin()：清理并退出ncurses模式

注意：所有ncurses程序都应该以initscr()开始，以endwin()结束。忘记调用endwin()可能导致终端处于不正常的状态。

3.2 ncurses的核心概念

理解ncurses的几个核心概念对于后续开发非常重要：

虚拟屏幕：ncurses维护一个虚拟屏幕缓冲区，所有输出操作首先作用于这个缓冲区，直到调用refresh()才会显示到实际屏幕。
窗口系统：ncurses支持创建多个窗口（WINDOW结构体），每个窗口可以独立操作。
坐标系统：ncurses使用(y,x)坐标系统，原点(0,0)在屏幕左上角。
输入处理：ncurses提供了强大的输入处理能力，包括特殊键（如方向键、功能键）的识别。

4. ncurses输出功能详解

4.1 基本输出函数

ncurses提供了多种输出函数，最常用的包括：

c复制int printw(const char *fmt, ...);  // 类似printf的格式化输出
int addch(char ch);                // 输出单个字符
int addstr(const char *str);       // 输出字符串

这些函数的行为与标准C库中的对应函数类似，但作用于ncurses的虚拟屏幕。

4.2 定位输出

要在特定位置输出内容，可以使用带"mv"前缀的函数：

c复制int mvprintw(int y, int x, const char *fmt, ...);  // 移动到(y,x)后输出
int mvaddch(int y, int x, char ch);                // 移动到(y,x)后输出字符

例如，要在屏幕中央输出"Hello"：

c复制int max_y, max_x;
getmaxyx(stdscr, max_y, max_x);  // 获取屏幕尺寸
mvprintw(max_y/2, (max_x-5)/2, "Hello");

4.3 属性和颜色

ncurses支持文本属性和颜色，可以创建更丰富的界面：

c复制attron(A_BOLD);          // 启用粗体
printw("Bold text");
attroff(A_BOLD);         // 关闭粗体

start_color();           // 初始化颜色系统
init_pair(1, COLOR_RED, COLOR_BLACK);  // 定义颜色对
attron(COLOR_PAIR(1));   // 使用颜色对1
printw("Red text");
attroff(COLOR_PAIR(1));

提示：在使用颜色前必须调用start_color()初始化颜色系统。颜色对编号从1开始，0号保留为默认颜色。

5. 窗口管理

5.1 创建和管理窗口

除了默认的stdscr窗口，我们可以创建自己的窗口：

c复制WINDOW *newwin(int nlines, int ncols, int begin_y, int begin_x);

参数说明：

nlines：窗口高度（行数）
ncols：窗口宽度（列数）
begin_y：窗口左上角的y坐标
begin_x：窗口左上角的x坐标

创建窗口后，可以使用delwin()销毁它：

c复制int delwin(WINDOW *win);

5.2 窗口操作

对于创建的窗口，有一系列对应的操作函数，通常以"w"前缀：

c复制wprintw(win, "Text");    // 在指定窗口输出
wrefresh(win);           // 刷新指定窗口
box(win, 0, 0);          // 为窗口绘制边框

一个完整的窗口示例：

c复制WINDOW *win = newwin(10, 30, 5, 5);
box(win, 0, 0);          // 绘制边框
mvwprintw(win, 1, 1, "Window content");  // 在窗口内输出
wrefresh(win);           // 刷新窗口

5.3 子窗口和面板

ncurses还支持创建子窗口（subwindow）和使用面板（panel）库实现窗口叠加：

c复制WINDOW *subwin(WINDOW *orig, int nlines, int ncols, int begin_y, int begin_x);

子窗口共享父窗口的缓冲区，适合创建复杂的界面布局。面板库则提供了窗口叠加管理和深度控制功能。

6. 输入处理

6.1 基本输入

getch()是最基本的输入函数，它会等待并返回用户按下的键：

c复制int ch = getch();

对于普通ASCII字符，返回值就是字符的ASCII码。对于特殊键（如方向键），会返回特定的键码（如KEY_UP、KEY_DOWN等）。

6.2 特殊键处理

要识别特殊键，需要先启用键码模式：

c复制keypad(stdscr, TRUE);  // 启用特殊键识别

然后就可以处理方向键等功能键：

c复制int ch = getch();
switch(ch) {
    case KEY_UP:    // 上箭头
        // 处理代码
        break;
    case KEY_DOWN:  // 下箭头
        // 处理代码
        break;
    // 其他特殊键...
}

6.3 非阻塞输入

默认情况下，getch()会阻塞等待输入。要实现非阻塞输入：

c复制nodelay(stdscr, TRUE);  // 启用非阻塞模式
int ch = getch();       // 如果没有输入，立即返回ERR

在非阻塞模式下，如果没有输入可用，getch()会返回ERR。这在游戏或实时应用中非常有用。

7. 高级特性

7.1 鼠标支持

ncurses还支持鼠标事件处理：

c复制mousemask(ALL_MOUSE_EVENTS, NULL);  // 启用所有鼠标事件
MEVENT event;
int ch = getch();
if(ch == KEY_MOUSE && nc_getmouse(&event) == OK) {
    // 处理鼠标事件
}

7.2 多线程支持

在多线程程序中使用ncurses需要注意：

只在一个线程中调用ncurses函数
或者使用互斥锁保护ncurses调用
考虑使用notimeout()、raw()等函数调整输入行为

7.3 国际化支持

对于需要国际化支持的应用，可以使用ncurses的宽字符版本（ncursesw）：

c复制#include <ncursesw/ncurses.h>

宽字符版本支持Unicode字符和复杂的文本布局。

8. 实际应用示例

8.1 创建一个简单的文本编辑器

结合上述知识，我们可以创建一个简单的文本编辑器框架：

c复制#include <ncurses.h>

#define WIDTH 30
#define HEIGHT 10 

int startx = 0;
int starty = 0;

char *choices[] = { 
    "New",
    "Open",
    "Save",
    "Exit",
};
int n_choices = sizeof(choices) / sizeof(char *);

void print_menu(WINDOW *menu_win, int highlight);

int main() {
    WINDOW *menu_win;
    int highlight = 1;
    int choice = 0;
    int c;

    initscr();
    clear();
    noecho();
    cbreak();   // 禁用行缓冲
    startx = (80 - WIDTH) / 2;
    starty = (24 - HEIGHT) / 2;
    
    menu_win = newwin(HEIGHT, WIDTH, starty, startx);
    keypad(menu_win, TRUE);
    mvprintw(0, 0, "Use arrow keys to go up and down, Enter to select a choice");
    refresh();
    print_menu(menu_win, highlight);
    
    while(1) {
        c = wgetch(menu_win);
        switch(c) {
            case KEY_UP:
                if(highlight == 1)
                    highlight = n_choices;
                else
                    --highlight;
                break;
            case KEY_DOWN:
                if(highlight == n_choices)
                    highlight = 1;
                else 
                    ++highlight;
                break;
            case 10:  // Enter键
                choice = highlight;
                break;
            default:
                mvprintw(24, 0, "Charcter pressed is = %3d Hopefully it can be printed as '%c'", c, c);
                refresh();
                break;
        }
        print_menu(menu_win, highlight);
        if(choice != 0)  // 用户做出了选择
            break;
    }
    
    mvprintw(23, 0, "You chose choice %d with choice string %s\n", choice, choices[choice - 1]);
    clrtoeol();
    refresh();
    endwin();
    return 0;
}

void print_menu(WINDOW *menu_win, int highlight) {
    int x, y, i;    
    x = 2;
    y = 2;
    box(menu_win, 0, 0);
    for(i = 0; i < n_choices; ++i) {
        if(highlight == i + 1) {
            wattron(menu_win, A_REVERSE); 
            mvwprintw(menu_win, y, x, "%s", choices[i]);
            wattroff(menu_win, A_REVERSE);
        } else
            mvwprintw(menu_win, y, x, "%s", choices[i]);
        ++y;
    }
    wrefresh(menu_win);
}

8.2 创建一个简单的游戏

下面是一个使用ncurses创建的简单贪吃蛇游戏框架：

c复制#include <ncurses.h>
#include <stdlib.h>
#include <time.h>

#define WIDTH 50
#define HEIGHT 20

typedef struct {
    int x;
    int y;
} Position;

typedef struct {
    Position pos;
    int size;
    Position body[100];
    int direction;
} Snake;

typedef struct {
    Position pos;
    int eaten;
} Food;

void init_snake(Snake *snake) {
    snake->size = 3;
    snake->pos.x = WIDTH / 2;
    snake->pos.y = HEIGHT / 2;
    snake->direction = KEY_RIGHT;
    
    for(int i = 0; i < snake->size; i++) {
        snake->body[i].x = snake->pos.x - i;
        snake->body[i].y = snake->pos.y;
    }
}

void init_food(Food *food, Snake *snake) {
    int valid;
    do {
        valid = 1;
        food->pos.x = rand() % (WIDTH - 2) + 1;
        food->pos.y = rand() % (HEIGHT - 2) + 1;
        
        for(int i = 0; i < snake->size; i++) {
            if(snake->body[i].x == food->pos.x && 
               snake->body[i].y == food->pos.y) {
                valid = 0;
                break;
            }
        }
    } while(!valid);
    
    food->eaten = 0;
}

void draw_border(WINDOW *win) {
    box(win, 0, 0);
}

void draw_snake(WINDOW *win, Snake *snake) {
    for(int i = 0; i < snake->size; i++) {
        mvwaddch(win, snake->body[i].y, snake->body[i].x, 
                i == 0 ? '@' : '#');
    }
}

void draw_food(WINDOW *win, Food *food) {
    if(!food->eaten) {
        mvwaddch(win, food->pos.y, food->pos.x, '*');
    }
}

void update_snake(Snake *snake) {
    // 移动身体
    for(int i = snake->size - 1; i > 0; i--) {
        snake->body[i] = snake->body[i-1];
    }
    
    // 根据方向移动头部
    switch(snake->direction) {
        case KEY_UP:
            snake->body[0].y--;
            break;
        case KEY_DOWN:
            snake->body[0].y++;
            break;
        case KEY_LEFT:
            snake->body[0].x--;
            break;
        case KEY_RIGHT:
            snake->body[0].x++;
            break;
    }
}

int check_collision(Snake *snake) {
    // 检查是否撞墙
    if(snake->body[0].x <= 0 || snake->body[0].x >= WIDTH - 1 ||
       snake->body[0].y <= 0 || snake->body[0].y >= HEIGHT - 1) {
        return 1;
    }
    
    // 检查是否撞到自己
    for(int i = 1; i < snake->size; i++) {
        if(snake->body[0].x == snake->body[i].x && 
           snake->body[0].y == snake->body[i].y) {
            return 1;
        }
    }
    
    return 0;
}

int check_food(Snake *snake, Food *food) {
    if(snake->body[0].x == food->pos.x && 
       snake->body[0].y == food->pos.y) {
        return 1;
    }
    return 0;
}

int main() {
    srand(time(NULL));
    
    initscr();
    noecho();
    cbreak();
    keypad(stdscr, TRUE);
    nodelay(stdscr, TRUE);
    curs_set(0);
    
    WINDOW *game_win = newwin(HEIGHT, WIDTH, 1, 1);
    Snake snake;
    Food food;
    
    init_snake(&snake);
    init_food(&food, &snake);
    
    int ch;
    int score = 0;
    int game_over = 0;
    
    while(!game_over) {
        ch = getch();
        switch(ch) {
            case KEY_UP:
                if(snake.direction != KEY_DOWN)
                    snake.direction = KEY_UP;
                break;
            case KEY_DOWN:
                if(snake.direction != KEY_UP)
                    snake.direction = KEY_DOWN;
                break;
            case KEY_LEFT:
                if(snake.direction != KEY_RIGHT)
                    snake.direction = KEY_LEFT;
                break;
            case KEY_RIGHT:
                if(snake.direction != KEY_LEFT)
                    snake.direction = KEY_RIGHT;
                break;
            case 'q':
                game_over = 1;
                break;
        }
        
        update_snake(&snake);
        
        if(check_collision(&snake)) {
            game_over = 1;
            break;
        }
        
        if(check_food(&snake, &food)) {
            snake.size++;
            score += 10;
            init_food(&food, &snake);
        }
        
        wclear(game_win);
        draw_border(game_win);
        draw_snake(game_win, &snake);
        draw_food(game_win, &food);
        wrefresh(game_win);
        
        mvprintw(0, 0, "Score: %d", score);
        refresh();
        
        napms(100);  // 控制游戏速度
    }
    
    mvprintw(HEIGHT/2, WIDTH/2 - 5, "GAME OVER");
    mvprintw(HEIGHT/2 + 1, WIDTH/2 - 5, "Score: %d", score);
    refresh();
    getch();
    
    delwin(game_win);
    endwin();
    
    return 0;
}