依稀_yixy

（十四）EGE键盘消息

键盘

按键的

一、按键消息

按键消息说明

键盘按键按下会触发按键消息

键盘短按和长按是不一样的。按键轻轻按一下，就只会立刻产生一个按键按下消息，松开产生一个按键松开消息。长按时，会在一开始产生一个按键按下消息，一段时间后，开始大量产生按键按下消息，速度很快，松开时，产生一个按键松开消息。
按键按下消息，如下面所示
短按时
按键消息：*
长按时(每秒大概32个)
按键消息：* *************

EGE中，产生的键盘消息用下面的 key_msg 结构体保存，包含是什么按键，是按下还是松开，是否同时按下了辅助键的信息。

按键消息结构体

typedef struct key_msg {
    unsigned int msg;		//消息类型
    unsigned int key;		//按键码
    unsigned int flags;		//辅助键标志
}key_msg;

结构体key_msg 有三个成员，分别是按键消息类型，按键码和辅助键标志。

按键消息类型 msg

用来判断按键是按下还是松开
msg 表示消息类型,有以下几个枚举值

key_msg_down 键盘按下消息。
key_msg_up 键盘弹起消息。
key_msg_char 键盘字符输入消息。(测试时没检测到有这种类型的值)

定义如下：

typedef enum key_msg_e {
	key_msg_down    = 1,
	key_msg_up      = 2,
	key_msg_char    = 4,
}key_msg_e;

使用方法：
假设keyMsg是key_msg类型的变量

判断是否是按键按下消息

keyMsg.msg == key_msg_down

判断是否是按键松开消息

keyMsg.msg == key_msg_up

来试试按键消息类型的检测，多个按键按下都是可以的
不用纠结代码意思,做次按键短按，长按，松开的实验

#include 

int main()
{
	initgraph(640, 480, 0);
	setcaption("按键消息类型测试");
	
	setbkcolor(WHITE);
	setcolor(BLACK);

	int keyUpCount = 0, keyDownCount = 0, keyCharCount = 0;

	for (; is_run(); delay_fps(60)) {
		key_msg keyMsg = { 0 };

		while (kbmsg()) {
			keyMsg = getkey();
			switch(keyMsg.msg) {
				case key_msg_up: 	keyUpCount++; 	break;
				case key_msg_down:	keyDownCount++; break;
				case key_msg_char: 	keyCharCount++; break;
			}
		}
		cleardevice();
		xyprintf(100, 300, "down 计数 = %d    up 计数 = %d     char 计数 = %d",
			keyUpCount, keyDownCount, keyCharCount);
	}
	return 0;
}

可以看出，按键长按按键消息是这样的：
(1的时候长按，6的时候松开， 9的时候再长按，15的时候再松开)

消息类型	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
up							$\ \bullet$									$\ \bullet$
down		$\ \bullet$		$\ \bullet$	$\ \bullet$	$\ \bullet$				$\ \bullet$		$\ \bullet$	$\ \bullet$	$\ \bullet$	$\ \bullet$

按键码 key

用来 判断是来自哪个按键的消息

如果是按下和弹起的消息，key则表示按键虚拟键码，否则为gbk编码字符消息。
平时用来判断是否是键盘A键的消息，使用 if (keyMsg.key == ‘A’) 来判断即可。

关于虚拟键码，可以自己查看定义，这是windowsAPI定义的一些宏，对应键盘上的各种按键，一般以 VK_ 开头，如
ESC键: VK_ESCAPE
上方向键：VK_UP
右方向键：VK_RIGHT

虚拟键码数不足256个, 每个键码的值用一个字节即可表示

可以在VS中输入VK_UP, 然后按快捷键F12转到定义，就可以查看各种虚拟键码。

字母键的虚拟键码就等于它的大写字母的ASCII码值。

如果是想判断是否是上方向键的消息, if (keyMsg.key == VK_UP)

EGE中也自己定义的一些枚举值，与虚拟键码是相等的，可以使用ege中的定义，以 key_ 开头

typedef enum key_code_e {
	//鼠标左右中三键
	key_mouse_l     = 0x01,
	key_mouse_r     = 0x02,
	key_mouse_m     = 0x04,
	
	//退格，Tab，回车键
	key_back        = 0x08,
	key_tab         = 0x09,
	key_enter       = 0x0d,
	
	//辅助键
	key_shift       = 0x10,
	key_control     = 0x11,
	
	key_menu        = 0x12,
	key_pause       = 0x13,
	
	//大写锁定，esc键，空格键
	key_capslock    = 0x14,
	key_esc         = 0x1b,
	key_space       = 0x20,

	//上一页，下一页，行首，行尾
	key_pageup      = 0x21,
	key_pagedown    = 0x22,
	key_home        = 0x23,
	key_end         = 0x24,

	//方向键
	key_left        = 0x25,
	key_up          = 0x26,
	key_right       = 0x27,
	key_down        = 0x28,

	key_print       = 0x2a,
	key_snapshot    = 0x2c,
	
	//插入，删除键
	key_insert      = 0x2d,
	key_delete      = 0x2e,

	//大键盘数字键
	key_0           = 0x30,
	key_1           = 0x31,
	key_2           = 0x32,
	key_3           = 0x33,
	key_4           = 0x34,
	key_5           = 0x35,
	key_6           = 0x36,
	key_7           = 0x37,
	key_8           = 0x38,
	key_9           = 0x39,

	//字母键中的A键和Z键
	key_A           = 0x41,
	key_Z           = 0x5a,

	//windows键
	key_win_l       = 0x5b,
	key_win_r       = 0x5c,

	key_sleep       = 0x5f,

	//小键盘的数字键，就是九个数字围成九宫格那个
	key_num0        = 0x60,
	key_num1        = 0x61,
	key_num2        = 0x62,
	key_num3        = 0x63,
	key_num4        = 0x64,
	key_num5        = 0x65,
	key_num6        = 0x66,
	key_num7        = 0x67,
	key_num8        = 0x68,
	key_num9        = 0x69,
	
	//小键盘的符号键
	//EGE缺少定义，故拿虚拟键码来补充
	//VK_MULTIPLY       0x6A		*
	//VK_ADD            0x6B		+
	//VK_SEPARATOR      0x6C		
	//VK_SUBTRACT       0x6D		-
	//VK_DECIMAL        0x6E		.
	//VK_DIVIDE         0x6F		/

	//这个是键盘上方的12个功能键
	key_f1          = 0x70,
	key_f2          = 0x71,
	key_f3          = 0x72,
	key_f4          = 0x73,
	key_f5          = 0x74,
	key_f6          = 0x75,
	key_f7          = 0x76,
	key_f8          = 0x77,
	key_f9          = 0x78,
	key_f10         = 0x79,
	key_f11         = 0x7a,
	key_f12         = 0x7b,

	//小键盘数字锁
	key_numlock     = 0x90,
	
	key_scrolllock  = 0x91,

	//可能左右两边都有一个
	key_shift_l     = 0xa0,
	key_shift_r     = 0xa1,
	key_control_l   = 0xa2,
	key_control_r   = 0xa3,
	key_menu_l      = 0xa4,
	key_menu_r      = 0xa5,

	//大键盘上的符号键
	key_semicolon   = 0xba,		;	分号
	key_plus        = 0xbb,		+	加号
	key_comma       = 0xbc,		,	逗号
	key_minus       = 0xbd,		-	减号
	key_period      = 0xbe,		.	句号
	key_slash       = 0xbf,		/	右斜杠
	key_tilde       = 0xc0,		`	波浪符（下面的点）
	key_lbrace      = 0xdb,		[	左方
	key_backslash   = 0xdc,		\	反斜杠
	key_rbrace      = 0xdd,		]	右方
	key_quote       = 0xde,		'	引号

	key_ime_process = 0xe5,
}key_code_e;

从上面挑选一些比较常用的键码
方向键：上下左右
key_up, key_down, key_left, key_right
字母键：
大写字母的ASCII值，如S键， 'S’
大键盘的数字键:
key_数字
键盘右边的小键盘数字键
key_num数字

ESC键
key_esc
空格键
key_space

辅助键类型 flags

按键参数，可能为以下值的组合（位或的方式），如果没有那就是0了

key_flag_shift 表示同时按下了shift 键
key_flag_ctrl 表示同时按下了ctrl 键
key_flag_shift | key_flag_ctrl 表示同时按下了shift 键和ctrl 键

typedef enum key_flag_e {
	key_flag_shift  = 0x100,
	key_flag_ctrl   = 0x200,
}key_flag_e;

获取字符输入 getch()

如果你只是想判断是哪个按键按下的或者获取输入的字符，这里有种简单的方式，那就是 kbhit() 和 getch() 的组合
最常用的getch()，这时候程序会暂停，等待用户按下按键，返回值是按键输入的字符的ASCII值或者是功能键的码值。(这个码值不是虚拟键码，如果能用ASCII表示，那就是等于ASCII码，如果不能表示，那么码值大于255)

int ch = getch();

(特别注意)
getch() 返回的值需要用两个字节表示，部分键返回值大于0xFF, 所以不能用char存储，否则很可能被截断，应该用 int。

需要注意：

EGE中的 getch() 会返回一个码，这个码并不是虚拟键码，是输入的字符或者功能键的码值，有些按键能用shift辅助输入两种字符
字母键有大小写 之分,即返回大小写对应的ASCII码
返回的一般是按键输入字符对应的ASCII码。如果是功能键，返回的数值大于255。
用ASCII值表示的字符，可以在用 getkey() 获取按键消息后用 getch() 获取字符输入 ，但如果不是用ASCII码表示的字符，无法再获取按键消息后获取到。
鼠标左键双击和点击后拖动会产生按键消息，被getch()获取。
用getch() 获取字符输入后, 无法使用 getkey() 获取到按键的按键消息

如果不想暂停，可以使用 kbhit() 检测是否有字符输入，如果没有就跳过，有就读取字符，这样就不影响程序运行了。


//判断是否有按键字符输入，有就读取字符。
if (kbhit()) {
	int ch = getch();
	...
}

但是，一般都是用while一次读取出全部的消息


//判断是否有按键字符输入，有就读取字符。
while (kbhit()) {
	int ch = getch();
	...
}

&emsp因为用 if 的话，如果你帧率比较小，并且按键长按产生了大量的按键消息的话，处理就没那么快了。键盘消息就会堆积起来，有种滞后的感觉。当然，如果你帧率较快，那么单键长按就什么问题。(比较快是多快? 帧率大于34)
下面来看看滞后的情况，设置成每秒20帧，按键长按，然后松开，就会看到。

修改 delay_fps() 中的数来改变帧率，看看滞后的情况变化

#include 

int main()
{
	initgraph(640, 480, 0);
	setcaption("按键消息处理滞后");
	setbkcolor(WHITE);
	setcolor(BLACK);

	int keyCount = 0;
	for (; is_run(); delay_fps(20)) {
		key_msg keyMsg = { 0 };

		if (kbhit()) {
			int key = getch();
			keyCount++;
		}
		cleardevice();
		xyprintf(100, 300, "按键计数 = %d ",
			keyCount);
	}
	return 0;
}

所以一般是用while来处理，这样就能很快将键盘消息清空，而不用管帧率是多少
来看看，使用了while来处理，按键长按，即使是10FPS也没事。

绘图的部分不要放在while循环中，因为绘图是需要 控制帧率 的，在里面循环是非常快的，绘图放在里面while循环里面，相当于产生多少消息就绘制多少次，会占用过多的CPU

像按键计数这种不需要控制帧率的是可以放在while循环中

字符输入检测示例：

#include 

int main()
{
	initgraph(640, 480, 0);
	setcaption("按键消息处理");
	setbkcolor(WHITE);
	setcolor(BLACK);

	int keyCount = 0;
	
	for (; is_run(); delay_fps(10)) {
		cleardevice();
		//按键处理
		while (kbhit()) {
			int key = getch();
			keyCount++;
		}
		
		xyprintf(100, 300, "按键计数 = %d ",
			keyCount);
	}
	return 0;
}

按键按下 getch() 到底返回什么，可以通过实验的方式
下面是一段测试代码，按下什么键，就会显示 getch() 返回的码值
如，通过实验，方向键左上右下分别是293, 294, 295, 296

#define SHOW_CONSOLE
#include 
#include 

int main()
{
	initgraph(640, 480,0);
	setbkcolor(WHITE);
	
	for (; is_run(); delay_fps(60)) {
		while (kbhit()) {
			int key = getch();
			printf("%c, %d, %#x\n", key, key, key);
		}
	}

	closegraph();

	return 0;
}

获取按键消息 getkey()

这个是通过获取鼠标消息结构体的方式，结构体包含了更多的信息。
kbmsg() 和 getkey() 的组合, kbmsg() 判断有无按键消息，getkey() 则是获取按键消息。
getkey() 也会暂停程序，等待用户按下按键。getkey() 返回一个key_msg 结构体。
用法如下所示：

key_msg keyMsg = {0};
while (kbmsg()) {
	keyMsg = getkey();
	这里做简单的按键消息处理，但绘图的代码不应该放这里
}

绘图代码应该放在这里

鼠标左键双击和点击后拖动会产生按键消息，被getkey()获取。

得到 key_msg 后，就可以读取

消息类型(keyMsg.msg) : 判断是按下还是松开
按键值(keyMsg.key)：判断是什么按键
辅助键标志(keyMsg.flag)：判断有没有辅助键同时按下

按键消息检测示例：

#include 

int main()
{
	initgraph(640, 480, 0);
	setcaption("按键消息处理");
	setbkcolor(WHITE);
	setcolor(BLACK);

	int keyCount = 0;
	
	for (; is_run(); delay_fps(10)) {
		cleardevice();
		key_msg keyMsg = {0};
		//按键消息处理
		while (kbmsg()) {
			keyMsg = getkey();
			if (keyMsg.key == 'A' && keyMsg.msg == key_msg_down)
				keyCount++;
		}
		
		xyprintf(100, 300, "A键 按下计数 = %d ",
			keyCount);
	}
	return 0;
}

二、检测按键状态

判断某个按键是否按下。这个不需要处理按键消息，直接获取按键状态。
按下返回1，没按下返回0, 相当于 true 和 false
由于键盘电路问题，当某些按键同时按下时，会有无法识别出按键按下松开的现象。例如S键，D键和K键这三个按键，任意两个按下后，另一个按键是检测不出来按没按下的，这是电路问题。

int keystate(int key);

其中key是虚拟键码，如果虚拟键码是字母键或数字键（大键盘）的，就是它的字符值（大写）。
注意，字母键的表示使用大写，如检测A键，是 keystate(‘A’) , 而不是keystate(‘a’)
小键盘上的数字键则用其它宏表示，如数字3， VK_NUMPAD3。也可以使用上面EGE自己定义的 key_code_e 枚举值
也可以用来获取鼠标按键状态，如鼠标左键码 key_mouse_l

if (keystate(VK_ESCAPE)) {
    // ESC键按下了
}
或者
if (keystate(key_esc) {

}
检测A键
if (keystate('A') {

}

当然，检测按键也可以通过处理按键消息的方式，只不过比较麻烦

三、检测按键消息

检测单个按键消息

判断是否是某个按键按下的消息

if (keyMsg.key == 键码 && keyMsg.msg == key_msg_down)

判断是否是某个按键松开的消息

if (keyMsg.key == 键码 && keyMsg.msg == key_msg_up)

如何由按键消息得到按键的状态

检测按键的状态可以直接由 keystate() 检测，比较方便，但如果你想通过处理按键消息的方式来获得按键状态也是可以的
为按键设置一个状态变量，初始为up状态。在按键消息处理时，只要检测到该按键的down 消息，就把状态设为down 状态，若检测到该按键的 up消息，则把该按键的状态设置为 up.
下面是示例(非完整程序)，只适合单键按下，不适合多键同时按键的情况。

//按键状态
enum KeyState
{
	KEY_UP = 0,
	KEY_DOWN = 1
};

//记录按键的状态
KeyState keyState = KEY_UP;	

for (; is_run(); delay_fps(60)) {
	key_msg kMsg = { 0 };

	while (kbmsg()) {
		kMsg = getkey();
		keyState = (kMsg.msg == key_msg_down) ? KEY_DOWN : KEY_UP;
	}

	在这里由keyState的值就可得出按键的状态，
	当然，只能是对一个按键来说

}

如果想要正确检测多个按键，比如想检测26个字母键，就可以为每个按键都设置一个状态变量。检测到是对应的按键时，就为该按键设置状态。

//按键状态
enum KeyState
{
	KEY_UP = 0,
	KEY_DOWN = 1
};

//记录26个字母键按键的状态, KEY_UP等于0，只给出第一个初始值，那剩下的都是初始化为0，,正好是KEY_UP
KeyState keyStates[26] = {KEY_UP};	

for (; is_run(); delay_fps(60)) {
	key_msg kMsg = { 0 };

	while (kbmsg()) {
		kMsg = getkey();
		
		int keyId = kMsg.key;
		KeyState state = (kMsg.msg == key_msg_down) ? KEY_DOWN : KEY_UP;
		//如果是字母按键(键码都是用大写表示）
		if ('A' <= keyId && keyId <= 'Z')
			keyStates[keyId - 'A'] = state;
	}

	//这里可以由keyStates得出各个按键的状态
	
}

通过处理键盘消息来获取字母按键状态示例

键盘由于键盘主板电路问题，并不能识别很多个同时按下的情况，当已经有很多个按键同时按下时，如果有其它的一些按键按下，电路就有可能不能将其识别出来，比如S, D和K，我键盘上按下其中两个，剩下的一个按下是检测不出来的

#include 

enum KeyState
{
	KEY_UP,
	KEY_DOWN
};

const int SCREEN_WIDTH = 600, SCREEN_HEIGHT = 300;

int main()
{
	initgraph(SCREEN_WIDTH, SCREEN_HEIGHT, 0);
	setcaption("字母按键状态显示");

	setbkcolor(WHITE);
	setcolor(BLACK);
	setfillcolor(EGERGB(0XFF, 0x80, 0XFF));
	//透明文字背景，不然带色块的
	setfont(20, 0, "仿宋");
	setbkmode(TRANSPARENT);

	KeyState keyStates[26] = { KEY_UP };

	for (; is_run(); delay_fps(60)) {
		key_msg kMsg = { 0 };

		while (kbmsg()) {
			kMsg = getkey();

			int keyId = kMsg.key;
			KeyState state = (kMsg.msg == key_msg_down) ? KEY_DOWN : KEY_UP;
			//如果是字母按键
			if ('A' <= keyId && keyId <= 'Z')
				keyStates[keyId - 'A'] = state;
		}

		/*上面是做位置计算的，下面是根据位置绘图的部分*/

		//清屏
		cleardevice();

		//画按钮状态示意图
		for (int i = 0; i < 26; i++) {
			int x = 100 + i % 10 * 40;
			int y = 100 + i / 10 * 40;

			//按下时画色块
			if (keyStates[i] == KEY_DOWN) {
				bar(x, y, x + 38, y + 38);
			}
			//对应位置写字母
			xyprintf(x + 10, y + 10, "%c", 'A' + i);
		}
	}
		
	return 0;
}

只检测按键按下和松开动作

上面检测单个按键消息的判断只能单独判断一个键盘消息，但是因为实际上按住不放的时候会发出多个按下的消息。
将上面检测是否是按键按下消息的代码（即 kMsg.msg == key_msg_down ），用于人物移动判断的话，长按按键，人物会突然移动很多，就像上面按键消息计数程序一样，长按按键时，计数会快速增长。

下面是按下松开时键盘发出的 keymsg 消息：
1的时候长按，6的时候松开， 9的时候再长按，15的时候再松开

消息类型	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
up							$\ \bullet$									$\ \bullet$
down		$\ \bullet$		$\ \bullet$	$\ \bullet$	$\ \bullet$				$\ \bullet$		$\ \bullet$	$\ \bullet$	$\ \bullet$	$\ \bullet$

所以我们可以看出，按键长按时，过一小段时间后，会快速发出多条键盘按键按下 (down) 的消息，如果你用 kMsg.msg == key_msg_down 判断的话，长按一次按键，会检测到多次按键按下的消息。但检测到按键 松开(up) 的消息时，那就是松开的时刻，因为松开时只会发送一条消息。
所以将上面检测是否是按键按下消息的代码（即 kMsg.msg == key_msg_down ），用于人物移动判断的话，长按按键，人物会突然移动很多。
如果我们只需要按键按下一次人物移动一格，长按也不会继续移动时，可以只检测按键按下和松开的时刻。记录下按键的状态，这样按键按下和松开时状态会变化，只对状态变化的时刻做出反应 。这样的话，长按时，即使检测到按键按下的消息，但状态没有发生变化，因此不是按键刚按下的时候。

状态设置流程

用 lastKeyState，curKeyState 记录上次和当前的状态，初始值必须为 KEY_UP, 否则首次按下时判断失效。
在按键消息处理循环中, 对消息类型逐个判断，是松开 (up) 的消息就将curKeyState 设置为 KEY_UP, 是按下 (down) 的消息就设置为KEY_DOWN
按下时刻的判断, 即原本是松开，现在是按下的状态变化时刻。

if (lastKeyState == KEY_UP && curKeyState == KEY_DOWN)

松开时刻的判断, 即原本是按下，现在是松开的状态变化时刻。

if (lastKeyState == KEY_DOWN && curKeyState == KEY_UP)

最后不要忘了在所有涉及按键消息判断的代码外加上 lastKeyState = curKeyState，放在按键消息处理判断之前之后都是可以的，。

示例程序

#include 

//按键状态
enum KeyState
{
	KEY_UP,
	KEY_DOWN
};

int main()
{
	initgraph(640, 480, 0);
	setcaption("按键按下松开计数");
	setbkcolor(WHITE);
	setcolor(BLACK);

	//按键按下松开计数
	int keyUpCount = 0, keyDownCount = 0;
	
	//记录按键上一次的状态和现在的状态
	int lastKeyState = KEY_UP;
	int curKeyState = KEY_UP;
		

	for (; is_run(); delay_fps(60)) {
		key_msg kMsg = { 0 };
		//这个不能省
		lastKeyState = curKeyState;
		
		while (kbmsg())
		{
			kMsg = getkey();
			if (kMsg.msg == key_msg_up)
				curKeyState = KEY_UP;
			else if (kMsg.msg == key_msg_down)
				curKeyState = KEY_DOWN;
		}

		//按键按下
		if (lastKeyState == KEY_UP && curKeyState == KEY_DOWN)
			keyDownCount++;
		else if (lastKeyState == KEY_DOWN && curKeyState == KEY_UP)
			keyUpCount++;

		
		cleardevice();
		xyprintf(200, 200, "当前按键状态：%s", (curKeyState == KEY_UP) ? "松开" : "按下");
		xyprintf(200, 300, "down 计数 = %d", keyDownCount);
		xyprintf(200, 330, "up   计数 = %d", keyUpCount);	
	}
		
	return 0;
}

说明一下，这代码不适用于多按键同时按下的情况。多个按键同时按下并且长按时，如果有一个按键松开，状态显示会突然变成松开，然后又变回按下。

多按键情况

如果需要处理多键按下的情况，可以为每个按键分别定义两个状态变量，
只要消息处理时，根据 keyMsg.key 判断出是哪个按键，就设置对应按键的状态就行

少量按键可使用的方法

如果需要判断的按键只有几个，比如，判断常用的A, W, D, S四个方向键，则可以按照如下来写（非完整程序）

	#define KEY_NUM 4

	//这里设置好各个键的状态变量在数组中的下标
	const int KEY_A_INDEX = 0, KEY_W_INDEX = 1, KEY_D_INDEX = 2, KEY_S_INDEX = 3;
	
	//按键按下计数
	int keyDownCount[KEY_NUM] = { 0 };
	
	//记录按键上一次的状态和现在的状态
	int lastKeyState[KEY_NUM] = { KEY_UP };
	int curKeyState[KEY_NUM] = { KEY_UP };


	for (; is_run(); delay_fps(60)) {
		key_msg kMsg = { 0 };
		
		for (int i = 0; i < KEY_NUM; i++) {
			lastKeyState[i] = curKeyState[i];
		}
		
		while (kbmsg())
		{
			kMsg = getkey();
			
			int key = -1;

			//根据kMsg.key 判断哪个键按下
			switch (kMsg.key) {
			case 'A': key = KEY_A_INDEX; break;
			case 'W': key = KEY_W_INDEX; break;
			case 'D': key = KEY_D_INDEX; break;
			case 'S': key = KEY_S_INDEX; break;
			}
			//如果是四个键其中之一，那么key就会不是-1
			if (key >= 0) {
				if (kMsg.msg == key_msg_up)
					curKeyState[key] = KEY_UP;
				else if (kMsg.msg == key_msg_down)
					curKeyState[key] = KEY_DOWN;

				//不需控制帧率的按键处理等可以放在这里
				keyDownCount[key]++;
			}
		}

		//这里通过状态来判断按下情况， 这里只检测A键
		if (lastKeyState[KEY_A_INDEX] == KEY_UP && curKeyState[KEY_A_INDEX] == KEY_DOWN) {
			这里作A键按下时的绘图处理等
		}
			
		else if (lastKeyState[KEY_A_INDEX] == KEY_DOWN && curKeyState[KEY_A_INDEX] == KEY_UP) {
			这里作A键松开时的绘图处理等
		}

		//如果想遍历的话
		for (int i = 0; i < KEY_NUM; i++) {
			//如果按下
			if (lastKeyState[i] == KEY_UP && curKeyState[i] == KEY_DOWN) {
				
			}
		}

较多按键判断

因为键码只用一个字节就可以表示，即小于256，所以可以创建大小为256的状态变量数组。由键码直接对应下标。
对于 lastKeyState == curKeyState, 由于涉及过多的按键，状态变量的改变只会在某个按键按下或松开时，所以可以用一个数组，保存本次循环中有哪些键发出消息（即保存键码），只对这些按键赋值即可，这样可以减少一些操作。数组大小可以设置为256（虽然不可能有那么多按键在一帧里同时按下）。当然，也可以直接将256个状态变量遍历赋值，会多一些操作量，不过应该也没啥问题。
因为按键长按时会发出很多消息，所以不应该直接将本次的按键保存，而应该遍历之前保存的，看有没有这个按键的记录，没有就保存，按下按键的数目 + 1，有的话就不用记录了在一帧里，同时按下的按键数也就几个，所以这个操作也不是很多。
记得在帧循环开始将按下按键数置为 0

#define KEY_NUM 256

//记录按键上一次的状态和现在的状态
int lastKeyState[KEY_NUM] = { KEY_UP };
int curKeyState[KEY_NUM] = { KEY_UP };

//记录按下的按键
int pressKeyStack[256];
int pressKeyCount = 0;

for (; is_run(); delay_fps(60)) {
	key_msg kMsg = { 0 };

	//上次状态转换
	for (int i = 0; i < pressKeyCount; i++) {
		lastKeyState[pressKeyStack[i]] = curKeyState[pressKeyStack[i]];
	}

	pressKeyCount = 0;


	while (kbmsg())
	{
		kMsg = getkey();

		if (kMsg.msg == key_msg_up)
			curKeyState[kMsg.key] = KEY_UP;
		else if (kMsg.msg == key_msg_down)
			curKeyState[kMsg.key] = KEY_DOWN;

		//下面是对按下的按键进行记录
		//对按下的按键进行遍历，看有没有记录
		int i = 0;
		for (i = 0; i < pressKeyCount; i++) {
			if (pressKeyStack[i] == kMsg.key)
				break;
		}
		//i == pressKeyCount 说明没有记录
		if (i == pressKeyCount)
			pressKeyStack[pressKeyCount++] = kMsg.key;
	}

	//这里通过状态来判断按下情况, 判断A键
	if (lastKeyState['A'] == KEY_UP && curKeyState['A'] == KEY_DOWN) {

	}
	else if (lastKeyState['A'] == KEY_DOWN && curKeyState['A'] == KEY_UP) {

	}

	//判断空格键
	if (lastKeyState[key_space] == KEY_UP && curKeyState[key_space] == KEY_DOWN) {

	}
	else if (lastKeyState[key_space] == KEY_DOWN && curKeyState[key_space] == KEY_UP) {

	}
}

注意事项（初始化）

可以看到上面 keyMsg 是定义在帧循环里面的，这样每次循环，都会初始化一次。如果你定义在外面，在里面进行鼠标处理之前也要进行一次初始化，除非你想要处理上一次遗留下来的消息。因为如果当前没有键盘消息，keyMsg就不会赋值，如果没有初始化，那就是上一次检测留下来的值，这样如果直接对keyMsg进行检测的话就会造成误判。

几种初始化方式

定义在里面

for ( ; is_run(); delay_fps()) {
	key_msg keyMsg = {0};
}

定义在外面，里面结构体赋值

key_msg keyMsg = {0};
for ( ; is_run(); delay_fps()) {
	keyMsg = key_msg(0);
}

不进行初始化而直接检测的错误示例

下面是不进行初始化的示例，由于是直接对 keyMsg 进行检测，不初始化会造成误判。

#include 

int main()
{
	initgraph(640, 480, 0);
	setbkcolor(WHITE);
	setcolor(BLACK);

	//按键按下松开计数
	int keyCount = 0;
	xyprintf(200, 200, "按键下计数：%d", keyCount);

	key_msg keyMsg = { 0 };

	for (; is_run(); delay_fps(60)) {
		while (kbmsg()) {
			keyMsg = getkey();
		}

		if (keyMsg.msg == key_msg_down) {
			keyCount++;
			xyprintf(200, 200, "按键下计数：%d", keyCount);
		}
	}

	return 0;
}

下面是进行初始化后的，比较一下

#include 

int main()
{
	initgraph(640, 480, 0);
	setbkcolor(WHITE);
	setcolor(BLACK);

	//按键按下松开计数
	int keyCount = 0;
	xyprintf(200, 200, "按键下计数：%d", keyCount);

	key_msg keyMsg = { 0 };

	for (; is_run(); delay_fps(60)) {
		keyMsg = key_msg{ 0 };	//初始化
		while (kbmsg()) {
			keyMsg = getkey();
		}

		if (keyMsg.msg == key_msg_down) {
			keyCount++;
			xyprintf(200, 200, "按键下计数：%d", keyCount);
		}
	}

	return 0;
}

四、清空键盘消息缓存区

当你觉得缓存区中的键盘消息已经没有用时，可以将这些消息清空。这样下一次就能直接处理到最新的键盘消息了。

清空键盘消息缓存区的函数为

flushkey();

使用后将清空键盘消息缓存区，

五、人物移动示例

这里用小球来表示演示

(1) 普通的按键控制移动

会有突然移动很多的问题
短按和长按分别试试

里面的moveCheck() 函数可以直接拿来用，判断上下左右四个方向移动的，传入的分别是按键的键码和dx, dy的引用，得到的是格子的位置变化。

#include 


void drawGrid();

void moveCheck(int key, int& dx, int& dy);

enum KeyState
{
	KEY_UP,
	KEY_DOWN
};


const int SCREEN_WIDTH = 600, SCREEN_HEIGHT = 600;
const int radius = 20;

int main()
{
	const int COL = SCREEN_WIDTH / (2 * radius);
	const int ROW = SCREEN_HEIGHT / (2 * radius);
	initgraph(SCREEN_WIDTH, SCREEN_HEIGHT, INIT_RENDERMANUAL);
	setcaption("人物格子移动");

	//为了美观，使用抗锯齿
	ege_enable_aa(true);
	setbkcolor(EGEACOLOR(0XFF, WHITE));
	setcolor(BLACK);
	setfillcolor(EGEARGB(0XFF, 0XFF, 0, 0XFF));
	//透明文字背景，不然带色块的
	setbkmode(TRANSPARENT);


	int xCircle = COL / 2, yCircle = ROW / 2;

	for (; is_run(); delay_fps(60)) {

		key_msg kMsg = { 0 };

		while (kbmsg())
		{
			kMsg = getkey();
		}


		int dx = 0, dy = 0;
		//按键按下时
		if (kMsg.msg == key_msg_down) {
			//位置移动监测
			moveCheck(kMsg.key, dx, dy);

			//计算下一个位置在哪
			int xNext = xCircle + dx, yNext = yCircle + dy;
			//对下一个位置做边界检测，在边界内的才移动, 
			if (0 <= xNext && xNext < COL
				&& 0 <= yNext && yNext < ROW) {
				//如果里面有围墙，那么就需要再次判断要走到的位置是否是围墙
				xCircle += dx;
				yCircle += dy;
			}
		}
		/*上面是做位置计算的，下面是根据位置绘图的部分*/
		
		//清屏
		cleardevice();
		//画格子
		drawGrid();

		//高级绘图函数 画填充椭圆，可抗锯齿,这里的四个参数是(left, top, width, height)
		ege_fillellipse(xCircle * 2 * radius, yCircle * 2 * radius, 2 * radius, 2 * radius);

		xyprintf(5, 5, "当前位置：(%d, %d)", xCircle, yCircle);
	}

	return 0;
}

void drawGrid()
{
	for (int i = 0; i < SCREEN_WIDTH; i += 2 * radius) {
		line(i, 0, i, SCREEN_HEIGHT);
	}
	for (int j = 0; j < SCREEN_HEIGHT; j += 2 * radius) {
		line(0, j, SCREEN_WIDTH, j);
	}
}

void moveCheck(int key, int& dx, int& dy)
{
	switch (key) {
	case 'A': case key_left:	//左
		dx = -1; dy = 0;
		break;
	case 'W': case key_up:		//上
		dx = 0; dy = -1;
		break;
	case 'S': case key_down:	//下
		dx = 0; dy = 1;
		break;
	case 'D': case key_right:	//右
		dx = 1; dy = 0;
		break;
	default:					//其他键不移动
		dx = dy = 0;
		break;
	}
}

(2) 按键控制格子移动

按下一次只会移动一格，长按也不会多移动

#include 


void drawGrid();

void moveCheck(int key, int& dx, int& dy);

enum KeyState
{
	KEY_UP,
	KEY_DOWN
};


const int SCREEN_WIDTH = 600, SCREEN_HEIGHT = 600;
const int radius = 20;

int main()
{
	const int COL = SCREEN_WIDTH / (2 * radius);
	const int ROW = SCREEN_HEIGHT / (2 * radius);

	initgraph(SCREEN_WIDTH, SCREEN_HEIGHT, INIT_RENDERMANUAL);
	setcaption("人物格子移动");

	//为了美观，使用抗锯齿
	ege_enable_aa(true);
	setbkcolor(EGEACOLOR(0XFF, WHITE));
	setcolor(BLACK);
	setfillcolor(EGEARGB(0XFF, 0XFF, 0, 0XFF));
	//透明文字背景，不然带色块的
	setbkmode(TRANSPARENT);


	int xCircle = COL / 2, yCircle = ROW / 2;

	KeyState lastKeyState = KEY_UP;
	KeyState curKeyState = KEY_UP;

	for (; is_run(); delay_fps(60)) {

		key_msg kMsg = { 0 };

		while (kbmsg())
		{
			kMsg = getkey();
			if (kMsg.msg == key_msg_up)
				curKeyState = KEY_UP;
			else if (kMsg.msg == key_msg_down)
				curKeyState = KEY_DOWN;
		}

		int dx = 0, dy = 0;

		//有按键按键按下
		if (lastKeyState == KEY_UP && curKeyState == KEY_DOWN) {

			//根据按键做出移动判断
			moveCheck(kMsg.key, dx, dy);

			//判断一下位置有没有移动，如果是其它键按下的话，位置就没有移动，就不用做位置计算了
			if (dx != 0 || dy != 0) {
				//计算下一个位置在哪
				int xNext = xCircle + dx, yNext = yCircle + dy;
				//对下一个位置做边界检测，在边界内的才移动, 
				if (0 <= xNext && xNext < COL
					&& 0 <= yNext && yNext < ROW) {

					//如果里面有围墙，那么就需要再次判断要走到的位置是否是围墙
					xCircle += dx;
					yCircle += dy;
				}
			}
		}

		/*上面是做位置计算的，下面是根据位置绘图的部分*/


		//清屏
		cleardevice();
		//画格子
		drawGrid();

		//高级绘图函数 画填充椭圆，可抗锯齿，这里的四个参数是(left, top, width, height)
		ege_fillellipse(xCircle * 2 * radius, yCircle * 2 * radius, 2 * radius, 2 * radius);

		xyprintf(5, 5, "当前位置：(%d, %d)", (xCircle - radius) / (2 * radius), (yCircle - radius) / (2 * radius));

		//这个不能省
		lastKeyState = curKeyState;


	}

	return 0;
}

void drawGrid()
{
	for (int i = 0; i < SCREEN_WIDTH; i += 2 * radius) {
		line(i, 0, i, SCREEN_HEIGHT);
	}
	for (int j = 0; j < SCREEN_HEIGHT; j += 2 * radius) {
		line(0, j, SCREEN_WIDTH, j);
	}
}

void moveCheck(int key, int& dx, int& dy)
{
	switch (key) {
	case 'A': case key_left:	//左
		dx = -1; dy = 0;
		break;
	case 'W': case key_up:		//上
		dx = 0; dy = -1;
		break;
	case 'S': case key_down:	//下
		dx = 0; dy = 1;
		break;
	case 'D': case key_right:	//右
		dx = 1; dy = 0;
		break;
	default:					//其他键不移动
		dx = dy = 0;
		break;
	}
}

(3) 按键控制平滑移动

普通的按键移动不均匀，长按时会动一下，隔一段时间后再连续移动，不够平滑
而格子移动一次只能移动一格，显然不符合要求。
现在这里借助按键当前状态进行按键控制的平滑移动。每一帧都检测当前哪个按键处于按下状态，位置就往哪个方向增，而不用判断是否有按键按下。因为只根据当前状态，所以一个按键只用一个状态变量就够了。
检测按键状态使用 keystate()就可以了，自己使用鼠标消息来处理状态也可以，下面两个程序都将贴出
如果是四方向移动的，只判断出一个按下的方向键就够了，不用判断其它方向。如果是八方向移动的，就把所有按下的方向键的位置增量都加起来。这样，如果左和上同时按下时，会朝左上方向移动。
如果想平滑地拐弯，减速地停止，如同具有惯性，可以设置加速度，而不是速度dx, dy 突然变化，可以慢慢变化，如本来向左时匀速 dx = -10, dy = 0, 按下上方向键，这时候每一帧 dx的减小一点，dy增加一点，比如变成 dx = -8, dy = -2, 而不是突然变成dx = 0, dy = -10。
使用 keystate() 检测按键状态的方式
这种方式并不需要处理按键消息

 #include 

//窗口大小
const int SCREEN_WIDTH = 600, SCREEN_HEIGHT = 600;

const int radius = 40;		//圆半径大小

int main()
{
	initgraph(SCREEN_WIDTH, SCREEN_HEIGHT, INIT_RENDERMANUAL);
	setcaption("人物格子移动");

	//为了美观，使用抗锯齿
	ege_enable_aa(true);
	setbkcolor(EGEACOLOR(0XFF, WHITE));
	setcolor(BLACK);
	setfillcolor(EGEARGB(0XFF, 0XFF, 0, 0XFF));
	//透明文字背景，不然带色块的
	setbkmode(TRANSPARENT);

	//浮点型，精确位置，
	float xCircle = SCREEN_WIDTH / 2, yCircle = SCREEN_HEIGHT / 2;

	
	//0, 1, 2, 3分别对应方向 左 上 右 下
	int keys[4] = {'A', 'W', 'D', 'S'};
	int directKeys[4] = { key_left, key_up, key_right, key_down };
	//移动速度, 浮点型能任意控制速度快慢，
	float speed = 2.0f;
	float xSpeeds[4] = { -speed, 0, speed, 0 };
	float ySpeeds[4] = { 0,-speed, 0, speed };

	
	for (; is_run(); delay_fps(60)) {
		//根据按键按下状态对位置增量进行累加，可八方向移动
		float xNext = xCircle;
		float yNext = yCircle;

		for (int i = 0; i < 4; i++) {
			if (keystate(keys[i]) || keystate(directKeys[i])) {
				xNext += xSpeeds[i];
				yNext += ySpeeds[i];
			}
		}

		//如果移动了
		if (xNext != xCircle || yNext != yCircle) {
			//检测是否超出边界
			if (radius <= xNext && xNext <= (SCREEN_WIDTH - radius)
				&& radius <= yNext && yNext <= (SCREEN_HEIGHT - radius)) {
				xCircle = xNext;
				yCircle = yNext;
			}
		}

		/*上面是做位置计算的，下面是根据位置绘图的部分*/

		//清屏
		cleardevice();

		//高级绘图函数 画填充椭圆，可抗锯齿.这里的四个参数是(left, top, width, height)
		ege_fillellipse(xCircle - radius, yCircle - radius, 2 * radius, 2 * radius);

		xyprintf(5, 5, "当前位置：(%f, %f)", xCircle, yCircle);
	}

	return 0;
}

自己处理按键状态的方式

#include 

enum KeyState
{
	KEY_UP,
	KEY_DOWN
};

//窗口大小
const int SCREEN_WIDTH = 600, SCREEN_HEIGHT = 600;

const int radius = 40;		//圆半径大小

int main()
{
	initgraph(SCREEN_WIDTH, SCREEN_HEIGHT, INIT_RENDERMANUAL);
	setcaption("人物格子移动");

	//为了美观，使用抗锯齿
	ege_enable_aa(true);
	setbkcolor(EGEACOLOR(0XFF, WHITE));
	setcolor(BLACK);
	setfillcolor(EGEARGB(0XFF, 0XFF, 0, 0XFF));
	//透明文字背景，不然带色块的
	setbkmode(TRANSPARENT);

	//浮点型，精确位置，
	float xCircle = SCREEN_WIDTH / 2, yCircle = SCREEN_HEIGHT / 2;

	//0:左， 1：上， 2：右， 3：下
	KeyState keysState[4] = { KEY_UP };

	//移动速度, 浮点型能任意控制速度快慢，
	float speed = 2.0f;
	float xSpeeds[4] = {-speed, 0, speed, 0};
	float ySpeeds[4] = {0,-speed, 0, speed };

	for (; is_run(); delay_fps(60)) {

		key_msg kMsg = { 0 };

		while (kbmsg())
		{
			kMsg = getkey();

			//如果是方向键就改变方向键状态
			int keyNum = -1;

			switch (kMsg.key) {
			case 'A': case key_left:	//左
				keyNum = 0;
				break;
			case 'W': case key_up:	//上
				keyNum = 1;
				break;
			case 'D': case key_right:	//右
				keyNum = 2;
				break;
			case 'S': case key_down:	//下
				keyNum = 3;
				break;
			}
			
			//修改对应按键的状态
			if (keyNum >= 0) {
				if (kMsg.msg == key_msg_up)
					keysState[keyNum] = KEY_UP;
				else
					keysState[keyNum] = KEY_DOWN;
			}
		}

		//根据按键按下状态对位置增量进行累加，可八方向移动
		float xNext = xCircle;
		float yNext = yCircle;
		for (int i = 0; i < 4; i++) {
			if (keysState[i] == KEY_DOWN) {
				xNext += xSpeeds[i];
				yNext += ySpeeds[i];
			}
		}

		//如果移动了
		if (xNext != xCircle || yNext != yCircle) {
			//检测是否超出边界
			if (radius <= xNext && xNext <= (SCREEN_WIDTH - radius)
				&& radius <= yNext && yNext <= (SCREEN_HEIGHT - radius)) {
				xCircle = xNext;
				yCircle = yNext;
			}
		}

		/*上面是做位置计算的，下面是根据位置绘图的部分*/

		//清屏
		cleardevice();


		//高级绘图函数 画填充椭圆，可抗锯齿.这里的四个参数是(left, top, width, height)
		ege_fillellipse(xCircle - radius, yCircle - radius, 2 * radius, 2 * radius);

		xyprintf(5, 5, "当前位置：(%f, %f)", xCircle, yCircle);
	}

	return 0;
}

六. 键盘控制四方向移动写法

可以先定义一个方向变量 direction，初始值为-1。在按键处理时,当检测到方向键按下时，则把它赋值为对应的值。然后再检测 direction，如果不为-1，就代表刚才有方向键按下，这时就可以根据值来做不同的变化。

int direction = -1;

//按键消息处理
while (kbmsg()) {
	key_msg keyMsg = getkey();
	if (keyMsg.msg == key_msg_down) {
		switch(keyMsg.key) {
		case 'A': case key_left:	direction = 0;	break;
		case 'W': case key_up:		direction = 1;	break;
		case 'D': case key_right:	direction = 2;	break;
		case 'S': case key_down:	direction = 3;	break;
		}
	}
}

//这里根据direction的值判断，如果不是-1，说明按下了方向键
if (direction != -1) {
	//移动处理
}

因为四方向就是坐标 (x, y) 的变化，可以根据四个方向不同的变化定义变化量dx, dy 数组。
下面下标 0~3 分别对应左，上，右，下方向的坐标偏移

int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};

这样，得到方向direction 后，则可以做移动

x += dx[direction];
y += dy[direction];

下面是按键控制四方向格子移动的实例(按下按键)

#include 

#define NUM_GRID 10
#define GRID_WIDTH 50

const int SCR_WIDTH = GRID_WIDTH * NUM_GRID;
const int SCR_HEIGHT = SCR_WIDTH;

int main()
{
	initgraph(SCR_WIDTH, SCR_HEIGHT, 0);
	setbkcolor(WHITE);
	setcolor(BLACK);
	setfillcolor(EGERGB(0XFF, 0X80, 0XFF));
	setfont(14, 0, "楷体");
	setbkmode(TRANSPARENT);
	
	//当前格子位置
	int xGrid = NUM_GRID / 2, yGrid = xGrid;	
	
	//计算绘制位置，绘制
	int x = xGrid * GRID_WIDTH, y = yGrid * GRID_WIDTH;
	bar(x, y, x + GRID_WIDTH, y + GRID_WIDTH);
	xyprintf(x, y, "(%d, %d)", xGrid, yGrid);

	//方向坐标偏移量，0~3分别对应左上右下
	int dx[4] = { -1, 0, 1, 0 };
	int dy[4] = { 0, -1, 0, 1 };

	for (; is_run(); delay_fps(60)) {
		int direction = -1;

		//按键消息处理
		while (kbmsg()) {
			key_msg keyMsg = getkey();
			if (keyMsg.msg == key_msg_down) {
				switch (keyMsg.key) {
				case 'A': case key_left:	direction = 0;	break;
				case 'W': case key_up:		direction = 1;	break;
				case 'D': case key_right:	direction = 2;	break;
				case 'S': case key_down:	direction = 3;	break;
				}
			}
		}

		if (direction != -1) {
			//可以计算出下一个位置坐标
			int xGridNext = xGrid + dx[direction], yGridNext = yGrid + dy[direction];
			//判断移动是否会出边界，没出边界则移动
			if (0 <= xGridNext && xGridNext < NUM_GRID && 0 <= yGridNext && yGridNext < NUM_GRID) {
				cleardevice();
				//移动
				xGrid = xGridNext;
				yGrid = yGridNext;

				//计算绘制位置，绘制
				x = xGrid * GRID_WIDTH, y = yGrid * GRID_WIDTH;
				bar(x, y, x + GRID_WIDTH, y + GRID_WIDTH);
				xyprintf(x, y, "(%d, %d)", xGrid, yGrid);
			}
		}
	}

	closegraph();

	return 0;
}

你可能感兴趣的:(EGE)

Visual Studio配置EGE图形库独孤过 C/C++Microsoft Visual Studio Visual Studio C/C++
EGE(EasyGraphicsEngine)其实是对WindowsAPI的简单封装，适合图形库初学者。由于目前EGE是以C++风格进行封装，因此项目源文件应该使用.cpp文件。VisualStudio配置EGE图形库前期准备下载图形库目录组织结构配置方法创建项目添加源文件构建项目环境配置项目属性测试图形库前期准备下载图形库通过以下任一链接地址下载EGE图形库。EGE图形库主站下载地址：http:
DEV-C++ ege.h库绘图教程（六） S · B · Y · X EGE c++开发语言
一、前情回顾DEV-C++ege.h库绘图教程（一）DEV-C++ege.h库绘图教程（二）DEV-C++ege.h库绘图教程（三）DEV-C++ege.h库绘图教程（四）DEV-C++ege.h库绘图教程（五）那么今天，我们来讲一个比较简单的东西——音乐。二、音乐函数1.MUSIC类首先看一看类声明。classMUSIC{public:MUSIC();virtual~MUSIC();operat
C++播放音乐：使用EGE图形库快乐星空❥ 普普通通的程序那些事 c++java 前端
——开胃菜，闲话篓子一大片最近，我发现ege图形库不是个正经的图形库——那天，我又在打趣儿地翻代码时，无意间看到了这个：图形库？！你哪来的音乐（Music）呢？你™改名叫做音乐库算了吧！[豁然开朗]有谁还记得那件事：啧，这事儿不就有救了吗？——主食，干货篓子一大片第一步·准备工作1、Dev-C++或者VC++等制作环境2、一个CPP文件3、音乐RemeBerOurSummer（资源在最上面，自己下
EGE基础：输入篇依稀_yixy EGE EGE 输入
EGE专栏：EGE专栏EGE基础：输入篇文章目录一、sys_edit类1.头文件检查二、sys_edit类的使用1.使用步骤1.1输入框的创建1.2设置输入框参数1.2.1必要设置1.2.1.1输入框位置1.2.1.2输入框大小1.2.2非必要设置1.2.2.1允许输入的最大字符数1.2.2.2输入框背景颜色1.2.2.3输入框文字的颜色1.2.2.4输入框文字的字体1.2.2.5只读模式1.3设
EGE——通讯录诗酒伴年华 c++
一、简介1、基础功能：增、查、删、改2、界面的交互功能：鼠标和按钮的交互，按钮的点击效果，界面切换动态效果3、以文档格式储存对EGE中，窗口delay_fps()帧率刷新理解有一定提升。控制了重画界面的时机和次数，减小损耗；通过对redraw的不同赋值，实现界面内不同子界面的变化。二、界面相关代码头文件interface.h#pragmaonce#includeusingnamespacestd;
C/C++语言简易图形库EasyX库和EGE图形库百口可乐__ c++c语言 c++开发语言
有些学校直接拿VC来讲C语言，因为VC的编辑和调试环境都很优秀，并且VC有适合教学的免费版本。可惜在VC里面只能做一些文字性的练习题，想画条直线或一个圆都很难，例如需要注册窗口类、建消息循环等等，初学者会受严重打击的。初学编程想要绘图就得用TC，很是无奈。有些学校以TurboC为环境学习C语言，只是TurboC实在太老了，复制粘贴都很不方便。EasyXEasyXGraphicsLibrary是针对
大一程序设计期末大作业（飞机大战 C） Sankkl1 知识点及模板整理算法 c++c语言
用了一百多行代码做了一个相当简陋的飞机大战，用的是devc++，装了个ege库。文件部分素材都是网上找来抠的。。运行出来的效果十分简单，规则应该都知道，因为懒只有一种敌人和子弹，没有做出道具系统。代码#include#include#definewidth640#defineheight700#defineYSb160//子弹射出间隔#defineYSe500//敌人生成间隔#defineFT5/
EGE-UNet, 轻量化U-Net skyfengye 深度学习人工智能
随着transform的出现，现在语义分割网路结构越来越复杂，轻量化网路也较少了，有些轻量化也只是名义上的轻量化。今天我看到一篇很好的论文，上海交大发表在MICCAI2023的最新研究工作，一个称为EfficientGroupEnhancedUNet,EGE-UNet的模型，基于U-Net进行魔改，用于解决医学图像（尤其是皮肤病变）分割中面临的问题。其实一开始看到这个网络结构，我感觉有点恍惚，这都
C++小游戏贪吃蛇源码逃逸的卡路里 C++c++开发语言
graphics.h是针对DOS下的一个C语言图形库(c++也可以)目前支持下载此头文件的常用的有两种:1.EGE(EasyGraphicsEngine)2.EasyXGraphicsLibraryEGE,全名EasyGraphicsEngine,是windows下的简易绘图库，是一个类似BGI(graphics.h)的面向C/C++语言新手的图形库EasyX,全名EasyXGraphicsLib
Dev-C++利用EGE实现图形界面可视化 ོ栖落 C/C++c语言
一、EGE的安装在EGE的官网下载二、EGE的配置1、将EGE文件中的include文件复制到Dev-C++安装文件下的E:\DevC++6.7.5\Dev-Cpp\MinGW32\lib\gcc\mingw32\9.2.0\include目录下（根据自己的版本）。2、将EGE文件中的lib\mingw64\lib里面的“libgraphics64.a”这个文件复制到Dev-C++安装文件下的E:
学习记录——SegNetr、EGE-UNet、R2AU-Net、PHNet、CFNet Chaoy6565 分割 EGE-UNet CFNet 计算机视觉
SegNetr:Rethinkingthelocal-globalinteractionsandskipconnectionsinU-shapednetworks前导：集中于设计复杂的自注意力模块，以弥补基于卷积操作捕获长距离上下文依赖的不足，从而增加了网络的参数和计算复杂性；过于简单地融合编码器和解码器的特征，忽略了它们之间空间位置的关联性。论文引入了一种新颖的SegNetr块，可以在任意阶
学习记录——EGE-UNet、SCConv Chaoy6565 分割计算机视觉 UNet SCConv
EGE-UNet:anEfficientGroupEnhancedUNetforskinlesionsegmentation上海交大2023MICCAI 基于U-Net进行魔改，用于解决医学图像（尤其是皮肤病变）分割中面临的问题。由于它是针对移动健康应用开发的，解决了当前许多模型所面临的高参数和计算负载问题。EGE-UNet融合了两个主要模块：Groupmulti-axisHadamardPro
Dev-C++使用EGE绘图库实现燃放灿烂烟花的编写和发布软件开发技术深度爱好者 C C++学习编程实践系列 c++开发语言趣味程序
Dev-C++使用EGE绘图库实现燃放灿烂烟花的编写和发布前提是为Dev-C++配置EGE绘图库，详见Dev-C++使用EGE绘图库编程入门https://blog.csdn.net/cnds123/article/details/109982100灿烂烟花程序的编写灿烂烟花程序的目录结构：背景图片：背景音乐自己找个吧，文件名背景音乐.mp3燃放烟花.cpp文件内容如下：#include#incl
Dev-C++ 使用EGE绘图库编程入门（修订版）软件开发技术深度爱好者 C C++学习编程实践系列 c++ide
Dev-C++使用EGE绘图库编程入门（修订版）试验环境是DevCpp5.11（下载地址Dev-C++download|SourceForge.net）和ege19.01_all（下载地址http://xege.org/download/ege19.01_all.7z）EGE(EasyGraphicsEngine)是windows下的简易绘图库，简单，友好，容易上手，免费开源，而且因为接口意义直观
Window10 中Dev-C++ 使用EGE绘图库编程介绍与示例软件开发技术深度爱好者 C C++学习编程实践系列 c++开发语言
Window10中Dev-C++使用EGE绘图库编程介绍与示例EGE（EasyGraphicsEngine）是windows下的一个C++绘图库，操作简单，可以通过简单地调用实现在窗口上进行绘图，并且增加了鼠标，键盘等交互功能，可以完成简单的程序。试验环境是DevCpp5.11（下载地址Dev-C++download|SourceForge.net）和ege19.01_all(下载地址http:/
EGE专栏内容导航依稀_yixy EGE ege
专栏：EGE专栏文章目录EGE官方网址1.EGE官网2.库函数文档3.Github项目1.EGE配置相关1.1EGE配置教程1.2控制台设置1.3程序打包与图标修改2.EGE教程2.1EGE及资料文档介绍3.入门基础示例4.入门教程5.分类教程6.绘图方法与技巧7.编程相关8.示例程序EGE官方网址1.EGE官网https://xege.org/2.库函数文档EGE库函数文档3.Github项目w
devc c语言调用图片,DevC++中使用EGE图形库 weixin_39637700 devc c语言调用图片
以前一直使用VC++6.0进行编写，最近因为需要做一些简单的C语言教学，原来想使用Win-Tc来进行练习的，结果自己的电脑已经升级到了Windows10，用不了了。就找到了Dev-C++这个集中开发环境，总体来是的确非常适合初学者。简洁用好，就是没有代码自动提示比较遗憾一些。在使用Dev-C++后，在网上找到了一个EGE的图形库，感觉不错，就尝试着加入到Dev-C++的环境中。总体上比较顺利，也碰
【C语言】画图测试，基于DEV C++ EGE库帐1号1注1销1 c语言
#include#include#include#include//可以按a,d,w,s控制方向//可以按h控制发射子弹intmain(){chardirection='';intx=200,y=200,step=3,j=0;intcircle_x=x,circle_y=y;setinitmode(0);initgraph(640,480);floatf=-3.14;//用到循环，看起来比较炫酷些
EGE图形库基础及使用方法小熊coder GUI gui
文章目录一、前言1.EGE简单介绍2.EGE官方基础教程3.demo4.技术分享5.安装问题二、简单试玩三。官方手册一、前言1.EGE简单介绍EGE（EasyGraphicsEngine），是windows下的简易绘图库，是一个类似BGI(graphics.h)的面向C/C++语言新手的图形库，它的目标也是为了替代TC的BGI库而存在。它的使用方法与TC中的graphics.h相当接近，对新手来说
EGE20.08新版发布啦~抓住了8月的小尾巴！依稀_yixy EGE EGE C c++图形库
EGE更新啦在8月的最后一天发布了20.08版本(版本号命名是年份和月份)，抓住了8月的小尾巴! 相信你们已经会安装了，现在附上官网链接，赶紧下载安装，试一试吧！EGE官网（点击前往下载）：https://xege.org/ 点击红色框的链接就可以下载啦。Version20.08看看新版都有啥新特性库文件名统一为graphics[64].lib或libgraphics[64].a初始化图形
EGE基础入门篇（八）：清屏与重绘依稀_yixy EGE c++ege
EGE专栏：EGE专栏上一篇：EGE基础入门篇（七）：组合图形下一篇：EGE基础入门篇（九）：双缓冲与手动渲染一、清屏清屏即清除屏幕(clearscreen)，可以将窗口上的输出内容全部清空，是重绘常用的一种方法。1.控制台清屏在控制台下，执行cls命令将清除控制台中的所有输入输出，光标回到左上角。当控制台输出的字符内容达到一定行数的时候，控制台会自动向下滚动，以便用户能查看到最新的输
EGE绘图之三动画依稀_yixy EGE 动画 EGE
EGE专栏：EGE专栏上一篇：EGE绘图之二窗口刷新下一篇：EGE绘图之四Gif动图播放目录1.动画介绍1.1视觉暂留与似动知觉1.2动画原理1.3相关概念1.3.1帧1.3.2帧数与帧率1.3.3电影电视帧率和游戏帧率(FPS)1.3.4屏幕（显示器）刷新频率(HZ)2.EGE动画2.1绘制与清屏2.2帧率控制2.2.1获取实际帧率getfps()2.3帧循环2.3.1EGE中的帧循环3动画示例
EGE基础：高级绘图篇依稀_yixy EGE EGE
EGE专栏：EGE专栏目录一、EGE中的高级绘图函数1.高级绘图函数相比普通绘图函数的优势1.1图形边缘更为光滑1.2图形具有透明度二、高级函数的使用设置1.高级绘图函数设置流程图2.高级绘图函数使用流程2.1开启抗锯齿(==可选设置==)2.2设置ARGB颜色2.2.1ARGB颜色的表示2.2.2颜色设置2.3设置示例三、高级绘图函数的使用1.矩形区域参数1.1矩形区域参数类型1：(left,t
EGE基础：光栅操作篇依稀_yixy EGE
EGE专栏：EGE专栏目录光栅操作(1)光栅(2)二元光栅操作码(3)三元光栅操作码光栅操作(1)光栅光栅图也叫做位图、点阵图、像素图。图像其实由一个个像素点组成，每个像素点都有自己的颜色。显示屏就是由一个个的小点组成，当这些点都很小，而且都很紧密地排在一起时。我们就看到一幅连续的图像。但靠近看时，还是能看到一一的小点。输出时，是读取显存中的每一个点的颜色数据，然后根据颜色输出显示屏上。
EGE绘图之二窗口刷新依稀_yixy EGE EGE
EGE专栏：EGE专栏上一篇：EGE绘图之一绘图讲解下一篇：EGE绘图之三动画EGE绘图之二窗口刷新目录一、EGE的窗口刷新1.EGE窗口刷新流程2.渲染模式2.1自动渲染模式(不推荐)2.2手动渲染模式2.3手动渲染的开启3.如何主动请求EGE刷新窗口显示内容3.1调用delay_ms(0)3.2EGE刷新相关delay族函数3.2.1具有刷新窗口功能的延时函数3.2.2不具有刷新窗口功能的延时
EGE绘图之四 Gif动图播放依稀_yixy EGE EGE gif
专栏：EGE专栏上一篇：EGE绘图之三动画下一篇：EGE绘图之五按钮（上）目录一、Gif绘制1.动图加载1.1使用getimage()加载每一帧的图像1.2借助GDI+中的Bitmap类加载GIF动图2.Gif类2.1Gif.h2.2Gif.cpp2.3Gif的使用2.3.1使用示例：2.3.2初始化2.3.3加载图像2.3.4绑定设备2.3.5设置绘制位置，大小2.3.6切换至播放状态2.3.7
EGE示例程序——2048 依稀_yixy EGE #EGE示例程序游戏 2048 ege
EGE专栏：EGE专栏目录一、程序源码下载1.百度网盘（示例二2048）2.CSDN（示例二2048）二、2048游戏介绍三、EGE制作的2048游戏界面四、制作流程1.素材获取2.素材整理3.界面设计4.功能分析五、最基本的实现1.游戏设计1.1数据表示1.2图像加载1.3四方向移动1.3.1按键控制移动方向1.3.2移动1.4添加随机数2.基础版程序六、完整功能版实现1.重新开始2.添加音效3
基于c++EGE图形库编写的五子棋小游戏那些年丶我们逃过的课 c++小游戏 c++
基于c++EGE图形库编写的五子棋小游戏EGE图形库新手推荐使用EGE（EasyGraphicsEngine），是windows下的简易绘图库，是一个类似BGI(graphics.h)的面向C/C++语言新手的图形库，它的目标也是为了替代TC的BGI库而存在。它的使用方法与TC中的graphics.h相当接近，对新手来说，简单，友好，容易上手，免费开源，而且接口意义直观，即使是完全没有接触过图形编
C语言如何安装并使用图像处理函数，C语言如何加载使用图片 NGUP_LEE 程序员的日常 c++
1.codeblock如何安装图像处理函数先下载需要用的文件链接：https://pan.baidu.com/s/1uYY_-ahcw50MfXe5-UgQaw提取码：1tfq解压缩之后点开ege19.01_all文件夹。点开include文件夹。把ege.h和graphics.h和ege文件夹中六个.h文件复制到你电脑codeblock所在位置中include文件夹里面。之后找到下载文件中的li
ege 图片加载帐1号1注1销1 c++java c语言
#include#include#include//可以按a,d,w,s控制方向//可以按h控制发射子弹intmain(){chardirection='';intx=200,y=200,step=3,j=0;intcircle_x=x,circle_y=y;setinitmode(0);initgraph(640,480);PIMAGEimage=newimage(20,20);intret=g
java线程的无限循环和退出 3213213333332132 java
最近想写一个游戏，然后碰到有关线程的问题，网上查了好多资料都没满足。突然想起了前段时间看的有关线程的视频，于是信手拈来写了一个线程的代码片段。希望帮助刚学java线程的童鞋 package thread; import java.text.SimpleDateFormat; import java.util.Calendar; import java.util.Date
tomcat 容器 BlueSkator tomcat Web servlet
Tomcat的组成部分 1、server A Server element represents the entire Catalina servlet container. (Singleton) 2、service service包括多个connector以及一个engine，其职责为处理由connector获得的客户请求。 3、connector 一个connector
php递归,静态变量,匿名函数使用 dcj3sjt126com PHP 递归函数匿名函数静态变量引用传参
<!doctype html> <html lang="en"> <head> <meta charset="utf-8"> <title>Current To-Do List</title> </head> <body>
属性颜色字体变化周华华 JavaScript
function changSize(className){ var diva=byId("fot") diva.className=className; } </script> <style type="text/css"> .max{ background: #900; color:#039;
将properties内容放置到map中 g21121 properties
代码比较简单： private static Map<Object, Object> map; private static Properties p; static { //读取properties文件 InputStream is = XXX.class.getClassLoader().getResourceAsStream("xxx.properti
[简单]拼接字符串 53873039oycg 字符串
工作中遇到需要从Map里面取值拼接字符串的情况，自己写了个，不是很好，欢迎提出更优雅的写法，代码如下： import java.util.HashMap; import java.uti
Struts2学习云端月影
最近开始关注struts2的新特性，从这个版本开始，Struts开始使用convention-plugin代替codebehind-plugin来实现struts的零配置。配置文件精简了，的确是简便了开发过程，但是，我们熟悉的配置突然disappear了，真是一下很不适应。跟着潮流走吧，看看该怎样来搞定convention-plugin。使用Convention插件，你需要将其JAR文件放
Java新手入门的30个基本概念二 aijuans java 新手 java 入门
基本概念:　　1.OOP中唯一关系的是对象的接口是什么,就像计算机的销售商她不管电源内部结构是怎样的,他只关系能否给你提供电就行了,也就是只要知道can or not而不是how and why.所有的程序是由一定的属性和行为对象组成的,不同的对象的访问通过函数调用来完成,对象间所有的交流都是通过方法调用,通过对封装对象数据,很大限度上提高复用率。　　2.OOP中最重要的思想是类,类是模板是蓝图,
jedis 简单使用 antlove java redis cache command jedis
jedis.RedisOperationCollection.java package jedis; import org.apache.log4j.Logger; import redis.clients.jedis.Jedis; import java.util.List; import java.util.Map; import java.util.Set; pub
PL/SQL的函数和包体的基础百合不是茶 PL/SQL编程函数包体显示包的具体数据包
由于明天举要上课,所以刚刚将代码敲了一遍PL/SQL的函数和包体的实现(单例模式过几天好好的总结下再发出来);以便明天能更好的学习PL/SQL的循环,今天太累了,所以早点睡觉,明天继续PL/SQL总有一天我会将你永远的记载在心里,,, 函数; 函数:PL/SQL中的函数相当于java中的方法;函数有返回值定义函数的 --输入姓名找到该姓名的年薪 create or re
Mockito(二)--实例篇 bijian1013 持续集成 mockito 单元测试
学习了基本知识后，就可以实战了，Mockito的实际使用还是比较麻烦的。因为在实际使用中，最常遇到的就是需要模拟第三方类库的行为。比如现在有一个类FTPFileTransfer，实现了向FTP传输文件的功能。这个类中使用了a
精通Oracle10编程SQL(7)编写控制结构 bijian1013 oracle 数据库 plsql
/* *编写控制结构 */ --条件分支语句 --简单条件判断 DECLARE v_sal NUMBER(6,2); BEGIN select sal into v_sal from emp where lower(ename)=lower('&name'); if v_sal<2000 then update emp set
【Log4j二】Log4j属性文件配置详解 bit1129 log4j
如下是一个log4j.properties的配置 log4j.rootCategory=INFO, stdout , R log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appe
java集合排序笔记白糖_ java
public class CollectionDemo implements Serializable,Comparable<CollectionDemo>{ private static final long serialVersionUID = -2958090810811192128L; private int id; private String nam
java导致linux负载过高的定位方法 ronin47
定位java进程ID 可以使用top或ps -ef |grep java ![图片描述][1] 根据进程ID找到最消耗资源的java pid 比如第一步找到的进程ID为5431 执行 top -p 5431 -H ![图片描述][2] 打印java栈信息 $ jstack -l 5431 > 5431.log 在栈信息中定位具体问题将消耗资源的Java PID转
给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数 bylijinnan 函数
import java.util.ArrayList; import java.util.List; import java.util.Random; public class RandNFromRand5 { /** 题目：给定能随机生成整数1到5的函数，写出能随机生成整数1到7的函数。解法1： f(k) = (x0-1)*5^0+(x1-
PL/SQL Developer保存布局 Kai_Ge
近日由于项目需要，数据库从DB2迁移到ORCAL，因此数据库连接客户端选择了PL/SQL Developer。由于软件运用不熟悉，造成了很多麻烦，最主要的就是进入后，左边列表有很多选项，自己删除了一些选项卡，布局很满意了，下次进入后又恢复了以前的布局，很是苦恼。在众多PL/SQL Developer使用技巧中找到如下这段： &n
[未来战士计划]超能查派[剧透,慎入] comsci 计划
非常好看,超能查派,这部电影......为我们这些热爱人工智能的工程技术人员提供一些参考意见和思想........ 虽然电影里面的人物形象不是非常的可爱....但是非常的贴近现实生活.... &nbs
Google Map API V2 dai_lm google map
以后如果要开发包含google map的程序就更麻烦咯 http://www.cnblogs.com/mengdd/archive/2013/01/01/2841390.html 找到篇不错的文章，大家可以参考一下 http://blog.sina.com.cn/s/blog_c2839d410101jahv.html 1. 创建Android工程由于v2的key需要G
java数据计算层的几种解决方法2 datamachine java sql 集算器
2、SQL SQL/SP/JDBC在这里属于一类，这是老牌的数据计算层，性能和灵活性是它的优势。但随着新情况的不断出现，单纯用SQL已经难以满足需求，比如： JAVA开发规模的扩大，数据量的剧增，复杂计算问题的涌现。虽然SQL得高分的指标不多，但都是权重最高的。成熟度：5星。最成熟的。
Linux下Telnet的安装与运行 dcj3sjt126com linux telnet
Linux下Telnet的安装与运行 linux默认是使用SSH服务的而不安装telnet服务如果要使用telnet 就必须先安装相应的软件包即使安装了软件包默认的设置telnet 服务也是不运行的需要手工进行设置如果是redhat9，则在第三张光盘中找到 telnet-server-0.17-25.i386.rpm
PHP中钩子函数的实现与认识 dcj3sjt126com PHP
假如有这么一段程序： function fun(){ fun1(); fun2(); } 首先程序执行完fun1()之后执行fun2()然后fun()结束。但是，假如我们想对函数做一些变化。比如说，fun是一个解析函数，我们希望后期可以提供丰富的解析函数，而究竟用哪个函数解析，我们希望在配置文件中配置。这个时候就可以发挥钩子的力量了。我们可以在fu
EOS中的WorkSpace密码修改蕃薯耀修改WorkSpace密码
EOS中BPS的WorkSpace密码修改 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 201
SpringMVC4零配置--SpringSecurity相关配置【SpringSecurityConfig】 hanqunfeng SpringSecurity
SpringSecurity的配置相对来说有些复杂，如果是完整的bean配置，则需要配置大量的bean，所以xml配置时使用了命名空间来简化配置，同样，spring为我们提供了一个抽象类WebSecurityConfigurerAdapter和一个注解@EnableWebMvcSecurity，达到同样减少bean配置的目的，如下： applicationContex
ie 9 kendo ui中ajax跨域的问题 jackyrong AJAX跨域
这两天遇到个问题，kendo ui的datagrid，根据json去读取数据，然后前端通过kendo ui的datagrid去渲染，但很奇怪的是，在ie 10,ie 11,chrome,firefox等浏览器中，同样的程序，浏览起来是没问题的，但把应用放到公网上的一台服务器，却发现如下情况： 1） ie 9下，不能出现任何数据，但用IE 9浏览器浏览本机的应用，却没任何问题
不要让别人笑你不能成为程序员 lampcy 编程程序员
在经历六个月的编程集训之后，我刚刚完成了我的第一次一对一的编码评估。但是事情并没有如我所想的那般顺利。说实话，我感觉我的脑细胞像被轰炸过一样。手慢慢地离开键盘，心里很压抑。不禁默默祈祷：一切都会进展顺利的，对吧？至少有些地方我的回答应该是没有遗漏的，是不是？难道我选择编程真的是一个巨大的错误吗——我真的永远也成不了程序员吗？我需要一点点安慰。在自我怀疑，不安全感和脆弱等等像龙卷风一
马皇后的贤德 nannan408
马皇后不怕朱元璋的坏脾气，并敢理直气壮地吹耳边风。众所周知，朱元璋不喜欢女人干政，他认为“后妃虽母仪天下，然不可使干政事”，因为“宠之太过，则骄恣犯分，上下失序”，因此还特地命人纂述《女诫》，以示警诫。但马皇后是个例外。　　有一次，马皇后问朱元璋道：“如今天下老百姓安居乐业了吗？”朱元璋不高兴地回答：“这不是你应该问的。”马皇后振振有词地回敬道：“陛下是天下之父，
选择某个属性值最大的那条记录（不仅仅包含指定属性，而是想要什么属性都可以） Rainbow702 sql group by 最大值 max 最大的那条记录
好久好久不写SQL了，技能退化严重啊！！！直入主题：比如我有一张表，file_info，它有两个属性（但实际不只，我这里只是作说明用）： file_code, file_version 同一个code可能对应多个version 现在，我想针对每一个code，取得它相关的记录中，version 值最大的那条记录， SQL如下： select *
VBScript脚本语言 tntxia VBScript
VBScript 是基于VB的脚本语言。主要用于Asp和Excel的编程。 VB家族语言简介 Visual Basic 6.0 源于BASIC语言。由微软公司开发的包含协助开发环境的事
java中枚举类型的使用 xiao1zhao2 java enum 枚举 1.5新特性
枚举类型是j2se在1.5引入的新的类型,通过关键字enum来定义,常用来存储一些常量. 1.定义一个简单的枚举类型 public enum Sex { MAN, WOMAN } 枚举类型本质是类,编译此段代码会生成.class文件.通过Sex.MAN来访问Sex中的成员,其返回值是Sex类型. 2.常用方法静态的values()方