介绍curses库的使用，介绍curses工作原理、常见的函数使用，Linux下定时器、闹钟信号的使用、最后以一个贪吃蛇游戏案例，介绍curses库的综合应用效果。

这份文档是2017年写的，属于硬盘存货，当初编写时curses库的简介、函数使用很多都参考于网络其他博客，但是时间太久了不清楚来源了。

一、 curses简介

curses是一个在Linux/Unix下广泛应用的图形函数库.，作用是可以绘制在DOS下的用户界面和漂亮的图形。

curses 的命名是来自一个叫做“cursor optimization " （光标最优化）的双关语。curses 构成了一个工作在底层终端代码之上的封装，并向用户提供了一个灵活高效的API ( Application Programming Interface 应用程序接口）。

curses提供了移动光标，建立窗口，产生颜色，处理鼠标操作等功能。

 示例

如果要调用ncurses 库中的函数，必须在代码中加载ncurses.h 文件，就是要在C程序开头添加“#include <ncurses.h>”，然后在编译链接时标记lncurses参数。（注：ncurses 库已经包含“stdio.h”）。

因为curses库不在标准路径上, 所以我们要加上 -lcurses连接选项, 像这样：gcc -o hello hello.c -lcurses

格式示例：

二、curses工作原理

curses窗口是由curses系统定义的一个假想的屏幕，即逻辑屏幕。并不像Windows 平台上的窗口那样具有边框。当curses 初始化的时候，它会默认创建一个叫做stdscr 的窗口。这个窗口的屏幕一般是80列，24 行（根据显示环境的不同，可能会出现不同的大小）。

逻辑屏幕的布局是一个字符数组，数组下标为行号和列号组成。位置（0，0）是屏幕的左上角curses函数使用的坐标是y值（行号）在前，x值（列号）在后。

stdscr数据结构指的是“标准屏幕”，它的工作原理和stdio函数库中的标准输出stdout非常相似，在curses程序里，它是缺省的输出窗口。

curscr数据结构指的是“当前屏幕”。在程序调用refresh之前，输出数据是不会出现在标准屏幕上的。refresh被调用时，curses会比较stdscr与curscr的内容，只刷新发生改变的部分。

在一个curses程序里，输出一个字符的过程是：

(1)使用curses函数刷新一个逻辑屏幕(例如: printw("hello world!\n"); )

(2)请求curses用refresh刷新物理屏幕

重要的几个函数功能解析：

initscr()函数将终端屏幕初始化为curses 模式，它用来清除屏幕上所有的字符，并等待下一步处理。在调用其它的curses 函数前，要先调initscr()函数初始化屏幕。initscr()初始化了curses 系统并且为当前屏幕（也就是“stdscr”）和相关的数据结构分配内存

通过endwin()函数退出curses 模式。endwin()函数释放了curses 子系统和相关数据结构占用的内存必须是在完成所有的curses 操作以后才可以调用。

在使用printw 函数打印“Hello World！！！”时，实际上这个消息打印到了一个叫作“stdscr”的虚拟窗口上，没有被直接输出到屏幕上。

printw()函数的作用是不断将一些显示标记和相关的数据结构写在虚拟显示器上，并将这些数据写入stdscr 的缓冲区内。为了显示这些缓冲区中的数据我们必须使用refresh（）函数告诉curses系统将缓冲区的内容输出到屏幕上。

三、curses函数说明

3.1 初始化函数系列

3.2 输出函数系列

在curses 函数中有三类输出函数，它们分别是：

addch()系列：将单一的字符打印到屏幕上，可以附加加字符修饰参数的一类函数。

printw()系列：和printf()一样的具有格式化输出的一类函数。

addstr()系列：打印字符串的一类函数。

示例：

3.3 输入函数系列

输入函数也被分为三种：

getch ()系列：读取一个字符的一类函数。

scanw()系列：按照格式化读取输入的一类函数。

getstr()系列：读取字符串的一类函数。

示例：

3.4 屏幕光标位置处理

示例：

示例：（屏幕最大的行和列）

3.5 清除屏幕函数

示例：

3.6 设置字符的属性

每个curses字符都可以有特定的属性，属性控制着这个字符在屏幕上的显示方式，当然前提是显示设备硬件能够支持要求的属性

函数集合：

示例：

3.7 窗口创建与边框绘制

窗口（Window）机制是整个curses 系统的核心，可能需要将屏幕分成几个部分并分别处理，然而，将屏幕拆分成各个窗口，然后独立处理每个窗口是比较高效的方法。

WINDOW结构通常定义在ncurses.h头文件里，对它的存取操作必须按照规定的指令进行，程序永远不允许直接访问它标准屏幕stdscr是WINDOW结构的一个特例。

函数：

示例：

3.8 刷新窗口

3.9 彩色字体显示

大多数的curses实现都开始支持彩色显示功能，屏幕的每一个字符位置都可以从多种颜色里挑一种写上去，它的背景也可以从多种颜色里挑选，通过has_colors()函数来判断终端是否支持彩色显示功能，如果可以返回true，否则返回false。

颜色组合

示例：

3.10 改变窗口前后背景色wbkgd

示例：

3.11 设置键盘的工作方式

对工作模式进行设置的函数如下所示：

raw()和cbreak()的区别

通常情况下，终端驱动程序会缓冲用户输入的字符，直到遇到换行符或回车符后，这些字符才可以被使用。

raw()和cbreak()两个函数都可以禁止行缓冲（line buffering）。

在raw()函数模式下，处理挂起（CTRL+Z）、中断或退出（CTRL+C）等控制字符时，将直接传送给程序去处理而不产生终端信号；

cbreak()模式下，控制字符将被终端驱动程序解释成其它字符。

3.12 获取键盘按键

对各个终端来说，它的每一个功能键发送出来的转义序列通常都被保存在一个terminfo结构里，而头文件curses.h通过一组以“KEY_”为前缀的定义把功能键都预先安排好了.（grep KEY ncurses.h | less）curses在启动时会关闭转义序列与逻辑按键之间的转换功能。

示例：

3.13 隐藏光标

填入的值分别为：0、1、2 对应着不可见，正常，高亮。

四、疑难杂症

4.1 中文显示乱码解决

1、引入本地头文件

在main函数文件中添加#include <locale.h>头文件

2、改变gcc编译链接指令

将gcc ..... -lcurses或gcc ..... -lncurses改为gcc ...... -lncursesw

3、设置本地字符编码(最重要的一点)

一般是在main函数中，在初始化curses库的initscr()函数前先调用setlocale(LC_ALL,"")

五、其他函数说明

5.1 Linux下定时器信号

在linux下如果对定时要求不太精确的话，使用alarm()和signal()就行了，但是如果想要实现精度较高的定时功能的话，就要使用setitimer函数。

示例：

5.2 精确定时

linux上定时函数 setitimer 的使用介绍：

参数介绍：

​ which为定时器类型，setitimer支持3种类型的定时器：

ITIMER_REAL: 以系统真实的时间来计算，它送出SIGALRM信号。

ITIMER_VIRTUAL: -以该进程在用户态下花费的时间来计算，它送出SIGVTALRM信号。

ITIMER_PROF: 以该进程在用户态下和内核态下所费的时间来计算，它送出SIGPROF信号。

setitimer()第一个参数which指定定时器类型（上面三种之一）；第二个参数是结构itimerval的一个实例；第三个参数可不做处理。

 setitimer()调用成功返回0，否则返回-1。

 形参如下

struct itimerval {

struct timeval it_interval;

struct timeval it_value;

};

struct timeval {

long tv_sec;

long tv_usec;

};

it_interval指定间隔时间，it_value指定初始定时时间。如果只指定it_value，就是实现一次定时；如果同时指定 it_interval，则超时后，系统会重新初始化it_value为it_interval，实现重复定时；两者都清零，则会清除定时器。

tv_sec提供秒级精度，tv_usec提供微秒级精度，以值大的为先，注意1s = 1000000us。

ovalue用来保存先前的值，常设为NULL。

如果是以setitimer提供的定时器来休眠，只需阻塞等待定时器信号就可以了。

实现一次定时

实现重复定时

六、界面编写示例

6.1 贪吃蛇游戏界面示例

6.2 贪吃蛇游戏代码示例

编译时加上: -lncursesw

示例：# gcc test.c -lncursesw

#include <stdio.h>  
#include <stdlib.h>  
#include <curses.h>  
#include <signal.h>  
#include <sys/time.h>  
#include <fcntl.h>  
#include <time.h>  
#include <locale.h>
  
#define INIT_POS_X         12  
#define INIT_POS_Y         40  
#define INIT_SNAKE_LENGTH  5  
#define MOVE_LEFT          1  
#define MOVE_RIGHT         2  
#define MOVE_UP            3  
#define MOVE_DOWN          4  
  
struct Snake  
{  
  int pos_x;  
  int pos_y;  
  struct Snake *pNext;  
  struct Snake *pPre;  
} *pSnakeHead,*pSnakeTail,*pSnakeTrace,*pSnakeFood;  
  
int  move_dir;  
int  is_game_over = 0;  
int  speed[5] = {200,150,120,100,80};  
int  snake_len = INIT_SNAKE_LENGTH;  
int  current_score;  
int  levelup_score[5] = {5,10,15,20,25};  
int  level = 0;  
int  life = 3;  
void init_wall();  
void init_snake();  
void show_snake(struct Snake *pSnake);  
void snake_move(int sig);  
int  set_ticker(long n_msecs);  
void getOrder();  
int  is_snake_dead();  
void put_food();  
void eat_food();  
void levelup();  
void over(int i);  
void reset_game();  
void delete_snake();  
  
int main(void)  
{  
  setlocale(LC_ALL,""); //设置本地编码，用于支持中文
  initscr();   //初始化curses模式
  clear();     //清除屏幕
  curs_set(0); //隐藏光标 
  init_wall();  //初始化界面显示
  init_snake();  
  put_food();  
  set_ticker(speed[level]);  
  noecho();  
  keypad(stdscr, true);  
  getOrder();  
  system("stty echo");  
  system("clear");  
  endwin();  
  exit(0);  
}  

//初始化界面显示
void init_wall()  
{  
  int i;
  addstr(" Linux下C语言版贪吃蛇游戏");   
  for(i = 0; i <COLS ; ++i)  
    {  
      move(3,i);  
      addstr("✪");  
    }  
  
  move(2,0);  
  printw("生命: %d", life);  
  move(2,COLS-10);  
  printw("分数:%2d",current_score);  
  move(2,COLS/2-5);  
  printw("次数:%d",level+1);  
  
  //设置背景颜色
  //start_color();
  //init_pair(1,COLOR_BLACK,COLOR_BLUE);
  //attroff(COLOR_PAIR(1)); //字体颜色
  //bkgd(COLOR_PAIR(1)); //背景色
  refresh();  
}  
  
void init_snake()  
{  
  int i;  
  struct Snake *pSnakePre;  
  int flag=0;  
  pSnakeTrace = (struct Snake *)malloc(sizeof(struct Snake));  
  pSnakeTrace->pos_x = 0;  
  pSnakeTrace->pos_y = 0;  
  for(i = 0; i < INIT_SNAKE_LENGTH; ++i)  
    {  
      struct Snake *pSnakeBody = (struct Snake *)malloc(sizeof(struct Snake));  
      pSnakeBody->pos_x = INIT_POS_X;  
      pSnakeBody->pos_y = INIT_POS_Y+INIT_SNAKE_LENGTH-i;  
      if (flag == 0)  
		{  
		  pSnakeHead = pSnakePre = pSnakeBody;  
		  pSnakeBody->pPre = NULL;  
		  flag++;  
		}  
		else  
		{  
		  pSnakePre->pNext = pSnakeBody;  
		  pSnakeBody->pPre = pSnakePre;  
		  pSnakeBody->pNext = NULL;  
		  pSnakePre = pSnakeBody;  
		}  
    }  
  pSnakeTail = pSnakePre;  
  move_dir = MOVE_RIGHT;  
  signal(SIGALRM,snake_move);  
  show_snake(pSnakeHead);  
}  
  
int set_ticker( long n_msecs )  
{  
  struct itimerval new_timeset;  
  long    n_sec, n_usecs;  
    
  n_sec = n_msecs / 1000 ;  
  n_usecs = ( n_msecs % 1000 ) * 1000L ;  
    
  new_timeset.it_interval.tv_sec  = n_sec;  
  new_timeset.it_interval.tv_usec = n_usecs;  
  new_timeset.it_value.tv_sec     = n_sec  ;  
  new_timeset.it_value.tv_usec    = n_usecs ;  
    
  return setitimer(ITIMER_REAL, &new_timeset, NULL);  
}  


void show_snake(struct Snake *pSnake)  
{  
  while(pSnake)  
    {  
       move(pSnake->pos_x,pSnake->pos_y);  
       addstr("☯"); //蛇身图案 
       pSnake = pSnake->pNext;  
    }  
  move(pSnakeTrace->pos_x,pSnakeTrace->pos_y);  
  addstr(" ");  
  refresh();  
}  
  
void snake_move(int sig)  
{  
  noecho();  
  pSnakeTrace->pos_x = pSnakeTail->pos_x;  
  pSnakeTrace->pos_y = pSnakeTail->pos_y;  
  struct Snake *ptemp;  
  ptemp = pSnakeTail->pPre;  
  pSnakeTail->pPre->pNext = NULL;  
  pSnakeTail->pPre = NULL;  
  pSnakeTail->pNext = pSnakeHead;  
  pSnakeHead->pPre = pSnakeTail;  
  pSnakeHead = pSnakeTail;  
  pSnakeTail = ptemp;  
  
  switch(move_dir)  
    {  
    case MOVE_LEFT:  
      pSnakeHead->pos_y = pSnakeHead->pNext->pos_y-1;  
      pSnakeHead->pos_x = pSnakeHead->pNext->pos_x;  
      break;  
    case MOVE_RIGHT:  
      pSnakeHead->pos_y = pSnakeHead->pNext->pos_y+1;  
      pSnakeHead->pos_x = pSnakeHead->pNext->pos_x;  
      break;  
    case MOVE_UP:  
      pSnakeHead->pos_x = pSnakeHead->pNext->pos_x-1;  
      pSnakeHead->pos_y = pSnakeHead->pNext->pos_y;  
      break;  
    case MOVE_DOWN:  
      pSnakeHead->pos_x = pSnakeHead->pNext->pos_x+1;  
      pSnakeHead->pos_y = pSnakeHead->pNext->pos_y;  
      break;  
    default:  
      break;  
    }  
  
  if((is_game_over = is_snake_dead()) != 0)  
    {  
      over(is_game_over);  
    }  
  
  if((pSnakeHead->pos_x == pSnakeFood->pos_x)  
      && (pSnakeHead->pos_y == pSnakeFood->pos_y))  
    {  
      eat_food();  
      put_food();  
      current_score++;  
      move(2,COLS-10);  
      printw("分数:%2d",current_score);  
    }  
  show_snake(pSnakeHead);  
  if(current_score == levelup_score[level])  
    {  
      levelup();  
    }  
  signal(SIGALRM,snake_move);  
}  
  
void getOrder()  
{  
   while(1)  
   {  
     char c = getch();  
     switch(c)  
	 {  
	 case 'a':  
	   move_dir=MOVE_LEFT;  
	   break;  
	 case 'd':  
	   move_dir=MOVE_RIGHT;  
	   break;  
	 case 'w':  
	   move_dir=MOVE_UP;  
	   break;  
	 case 's':  
	   move_dir=MOVE_DOWN;  
	   break;  
	 case 'q':  
	   system("stty echo");  
	   system("clear");  
	   endwin();  
	   exit(0);  
	   break;  
	 default:  
	   break;  
	 }  
   }  
}  
int is_snake_dead()  
{  
  struct Snake *pSnakeBody = pSnakeHead->pNext;  
  int k=0;  
  while(pSnakeBody)  
    {  
      if((pSnakeHead->pos_x == pSnakeBody->pos_x)  
     && (pSnakeHead->pos_y == pSnakeBody->pos_y) )  
    {  
      return 2;  
    }  
      pSnakeBody = pSnakeBody->pNext;  
      k++;  
    }  
  if ((pSnakeHead->pos_x == 3) || (pSnakeHead->pos_x == LINES)  
      || (pSnakeHead->pos_y == 0) || (pSnakeHead->pos_y == COLS) )  
    {  
      return 1;  
    }  
  return 0;  
}  
  
void put_food()  
{  
  int food_pos_x,food_pos_y;  
  int rangex,rangey;  
  int flag=0;  
  srand(time(NULL));  
  rangex = LINES-4;  
  rangey = COLS-1;  
  struct Snake *pTemp = pSnakeHead;  
  while(1)  
  {  
      flag = 0;  
      pTemp = pSnakeHead;  
      food_pos_x = rand()%rangex + 4;  
      food_pos_y = rand()%rangey + 1;  
    while(pTemp)  
    {  
      if((pTemp->pos_x == food_pos_x)&&(pTemp->pos_y == food_pos_y) )  
		{  
          flag++;  
        }  
      pTemp = pTemp->pNext;  
    }  
    
	if(flag ==0)  
    {  
      break;  
    }  
    }  
  struct Snake *pPutFood = (struct Snake *)malloc(sizeof(struct Snake));  
  pSnakeFood = pPutFood;  
  pSnakeFood->pos_x = food_pos_x;  
  pSnakeFood->pos_y = food_pos_y;  
  pSnakeFood->pPre = NULL;  
  pSnakeFood->pNext = NULL;  
  move(pSnakeFood->pos_x,pSnakeFood->pos_y);  
  addstr("❤");  //食物图案 
}  
  
void eat_food()  
{  
  pSnakeFood->pNext = pSnakeHead->pNext;  
  pSnakeHead->pNext->pPre = pSnakeFood;  
  pSnakeHead->pNext = NULL;  
  pSnakeTail->pNext = pSnakeHead;  
  pSnakeHead->pPre = pSnakeTail;  
  pSnakeTail = pSnakeHead;  
  pSnakeHead = pSnakeFood;  
}  
  
void levelup()  
{  
  if (level == 4)  
    {  
      move(0, 1);  
      addstr("完成游戏,按任意键重启游戏");  
      refresh();  
      set_ticker(0);  
      char c = getchar();  
      level = 0;  
      life = 3;  
      reset_game();  
    }  
  else  
    {  
      move(0, 1);  
      addstr("按任意键继续     ");  
      refresh();  
      set_ticker(0);  
      char c = getchar();  
      level++;  
      reset_game();  
  }  
}  
  
void delete_snake()  
{  
  struct Snake *pSnake;  
  pSnake = pSnakeHead;  
  while(pSnake)  
    {  
      free(pSnake);  
      pSnake = pSnake->pNext;  
    }  
  free(pSnakeFood);  
}  
  
void reset_game()  
{  
  current_score = 0;  
  delete_snake();  
  initscr();  
  clear();  
  init_wall();  
  init_snake();  
  put_food();  
  set_ticker(speed[level]);  
}  
  
void over(int i)  
 {  
   life--;  
   move(2,COLS/2-5);  
   printw("次数: %d", life);  
   if (life == 0)  
     {  
       move(0, 1);  
       addstr("游戏结束后,按任意键重启游戏               ");  
       refresh();  
       life = 3;  
       set_ticker(0);  
       char c = getchar();  
       level = 0;  
       reset_game();  
     }  
   else  
     {  
       move(0, 1);  
       if(1 == i)  
       {  
         addstr("撞墙,按任意键继续");  
       }  
       else if(2 == i)  
       {  
         addstr("咬尾事故,按任意键继续   ");  
       }  
       refresh();  
       set_ticker(0);  
       char c = getchar();  
       reset_game();  
     }  
}