c语言怎样实现当窗口失去焦点时按键检测

Sorawithcat

这是我用getch函数写的，但是不能失去焦点。

1. #include <stdio.h>
   
2. #include <conio.h>
   
3. 
   
4. void main()
   
5. {
   
6.         int anjian_d = 0;
   
7.         int anjian_f = 0;
   
8.         int anjian_j = 0;
   
9.         int anjian_k = 0;
   
10.         int anjian_sum = 0;
    
11.         while(1)
    
12.         {
    
13.                 if (_kbhit())
    
14.                 {
    
15.                        
    
16.                         switch (_getch())
    
17.                         {
    
18.                         case 'd':
    
19.                         case 'D':
    
20.                                 anjian_d++;
    
21.                                 break;
    
22.                         case 'f':
    
23.                         case 'F':
    
24.                                 anjian_f++;
    
25.                                 break;
    
26.                         case 'j':
    
27.                         case 'J':
    
28.                                 anjian_j++;
    
29.                                 break;
    
30.                         case 'k':
    
31.                         case 'K':
    
32.                                 anjian_k++;
    
33.                                 break;
    
34.                         }
    
35.                         system("cls");
    
36.                         anjian_sum = anjian_d + anjian_f + anjian_j + anjian_k;
    
37.                         printf("d:%d\nf:%d\nj:%d\nk:%d\nsum:%d\n", anjian_d, anjian_f, anjian_j, anjian_k,anjian_sum);
    
38.                 }
    
39.         }
    
40. }

复制代码

这是我用getkeystate写的，但是如果持续按键他会一直检测到，然后变量会一直在增加。

1. #include <stdio.h>
   
2. #include <conio.h>
   
3. #include <Windows.h>
   
4. 
   
5. void main()
   
6. {
   
7.         int ajd,ajD, ajf, ajj, ajk,ajF,ajJ,ajK;
   
8.         int anjian_d = 0;
   
9.         int anjian_f = 0;
   
10.         int anjian_j = 0;
    
11.         int anjian_k = 0;
    
12.         int anjian_sum = 0;
    
13.         while (1)
    
14.         {
    
15.                 if (_kbhit())
    
16.                 {
    
17.                         ajd = GetKeyState(100);
    
18.                         ajf = GetKeyState(102);
    
19.                         ajj = GetKeyState(106);
    
20.                         ajk = GetKeyState(107);
    
21.                         ajD = GetKeyState(68);
    
22.                         ajF = GetKeyState(70);
    
23.                         ajJ = GetKeyState(74);
    
24.                         ajK = GetKeyState(75);
    
25.                         if (ajd < 0 || ajD < 0)
    
26.                         {
    
27.                                 anjian_d++;
    
28.                                 goto end;
    
29.                         }
    
30.                         if (ajf < 0 || ajF < 0)
    
31.                         {
    
32.                                 anjian_f++;
    
33.                                 goto end;
    
34.                         }
    
35.                         if (ajJ < 0 || ajj < 0)
    
36.                         {
    
37.                                 anjian_j++;
    
38.                                 goto end;
    
39.                         }
    
40.                         if (ajK < 0 || ajk < 0)
    
41.                         {
    
42.                                 anjian_k++;
    
43.                         }
    
44.                 end:
    
45.                         system("cls");
    
46.                         anjian_sum = anjian_d + anjian_f + anjian_j + anjian_k;
    
47.                         printf("d:%d\nf:%d\nj:%d\nk:%d\nsum:%d\n", anjian_d, anjian_f, anjian_j, anjian_k, anjian_sum);
    
48.                 }
    
49.         }
    
50. }

复制代码

想问问怎么用getkeystate实现和getch一样的效果。

isdkz

可以使用GetForegroundWindow和GetFocus函数来获取当前窗口是否失去焦点，如果失去焦点就不再检测按键。同时，可以使用GetAsyncKeyState函数来检测按键是否按下，如果按下就执行相应的操作。

以下是代码示例：

1. #include <stdio.h>
   
2. #include <Windows.h>
   
3. 
   
4. void main() {
   
5.     int anjian_d = 0;
   
6.     int anjian_f = 0;
   
7.     int anjian_j = 0;
   
8.     int anjian_k = 0;
   
9.     int anjian_sum = 0;
   
10.     HWND hwnd = GetForegroundWindow();
    
11.     while (1) {
    
12.         if (hwnd != GetForegroundWindow() || GetFocus() != hwnd) {
    
13.             Sleep(100); // 等待100毫秒
    
14.             continue; // 如果窗口失去焦点，就不再检测按键
    
15.         }
    
16.         if (GetAsyncKeyState('D') & 0x8000) {
    
17.             anjian_d++;
    
18.         }
    
19.         if (GetAsyncKeyState('F') & 0x8000) {
    
20.             anjian_f++;
    
21.         }
    
22.         if (GetAsyncKeyState('J') & 0x8000) {
    
23.             anjian_j++;
    
24.         }
    
25.         if (GetAsyncKeyState('K') & 0x8000) {
    
26.             anjian_k++;
    
27.         }
    
28.         system("cls");
    
29.         anjian_sum = anjian_d + anjian_f + anjian_j + anjian_k;
    
30.         printf("d:%d\nf:%d\nj:%d\nk:%d\nsum:%d\n", anjian_d, anjian_f, anjian_j, anjian_k, anjian_sum);
    
31.         Sleep(100); // 等待100毫秒
    
32.     }
    
33. }
    

复制代码

在代码中，使用GetForegroundWindow函数获取当前窗口句柄，然后在循环中判断窗口是否失去焦点。如果窗口失去焦点，就使用Sleep函数等待100毫秒，然后重新开始循环。如果窗口没有失去焦点，就使用GetAsyncKeyState函数检测按键是否按下，并执行相应的操作。最后使用Sleep函数等待100毫秒，然后重新开始循环。

陶远航

在Windows环境下，GetKeyState函数可以用来检测键盘的按键状态，包括当窗口失去焦点时的按键状态。但是，GetKeyState函数会持续检测按键状态，即使按键已经被按下并释放，只要没有其他键被按下，它仍然会返回按键被按下的状态。这就是你在使用GetKeyState函数时，如果持续按键，变量会一直增加的原因。

要实现和getch一样的效果，即只在按键被按下的那一刻检测到按键，可以使用Windows的消息队列。当一个按键被按下时，Windows会将一个消息放入消息队列，你可以使用GetMessage或PeekMessage函数来获取这个消息。然后，你可以使用TranslateMessage和DispatchMessage函数来处理这个消息。

以下是一个使用消息队列来检测按键的示例代码：

1. #include <stdio.h>
   
2. #include <windows.h>
   
3. 
   
4. void main() {
   
5.     MSG msg;
   
6.     int anjian_d = 0;
   
7.     int anjian_f = 0;
   
8.     int anjian_j = 0;
   
9.     int anjian_k = 0;
   
10.     int anjian_sum = 0;
    
11. 
    
12.     while (1) {
    
13.         if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) {
    
14.             if (msg.message == WM_KEYDOWN) {
    
15.                 switch (msg.wParam) {
    
16.                 case 'd':
    
17.                 case 'D':
    
18.                     anjian_d++;
    
19.                     break;
    
20.                 case 'f':
    
21.                 case 'F':
    
22.                     anjian_f++;
    
23.                     break;
    
24.                 case 'j':
    
25.                 case 'J':
    
26.                     anjian_j++;
    
27.                     break;
    
28.                 case 'k':
    
29.                 case 'K':
    
30.                     anjian_k++;
    
31.                     break;
    
32.                 }
    
33.                 system("cls");
    
34.                 anjian_sum = anjian_d + anjian_f + anjian_j + anjian_k;
    
35.                 printf("d:%d\
    
36. f:%d\
    
37. j:%d\
    
38. k:%d\
    
39. sum:%d\
    
40. ", anjian_d, anjian_f, anjian_j, anjian_k, anjian_sum);
    
41.             }
    
42.         }
    
43.     }
    
44. }
    

复制代码

这段代码会创建一个消息循环，不断地从消息队列中取出消息并处理。当检测到一个按键被按下的消息时，它会增加相应的计数器，并更新显示的按键计数。

请注意，这段代码只能在Windows环境下运行，因为它使用了Windows的消息队列。在其他操作系统下，你可能需要使用不同的方法来检测按键。
请注意，本回答来自GPT-4
如果问题已经解决，请设置最佳答案

Mike_python小

对于需要在窗口失去焦点时检测按键的需求，可以使用Windows API函数来实现。你可以使用GetAsyncKeyState函数来获取按键状态。以下是修改后的代码示例：

2. #include <stdio.h>
3. #include <Windows.h>
5. int main() {
6.     int anjian_d = 0;
7.     int anjian_f = 0;
8.     int anjian_j = 0;
9.     int anjian_k = 0;
10.     int anjian_sum = 0;
12.     while (1) {
13.         if (GetAsyncKeyState('D') & 0x8000) {
14.             anjian_d++;
15.             system("cls");
16.             anjian_sum = anjian_d + anjian_f + anjian_j + anjian_k;
17.             printf("d:%d\nf:%d\nj:%d\nk:%d\nsum:%d\n", anjian_d, anjian_f, anjian_j, anjian_k, anjian_sum);
18.         }
20.         if (GetAsyncKeyState('F') & 0x8000) {
21.             anjian_f++;
22.             system("cls");
23.             anjian_sum = anjian_d + anjian_f + anjian_j + anjian_k;
24.             printf("d:%d\nf:%d\nj:%d\nk:%d\nsum:%d\n", anjian_d, anjian_f, anjian_j, anjian_k, anjian_sum);
25.         }
27.         if (GetAsyncKeyState('J') & 0x8000) {
28.             anjian_j++;
29.             system("cls");
30.             anjian_sum = anjian_d + anjian_f + anjian_j + anjian_k;
31.             printf("d:%d\nf:%d\nj:%d\nk:%d\nsum:%d\n", anjian_d, anjian_f, anjian_j, anjian_k, anjian_sum);
32.         }
34.         if (GetAsyncKeyState('K') & 0x8000) {
35.             anjian_k++;
36.             system("cls");
37.             anjian_sum = anjian_d + anjian_f + anjian_j + anjian_k;
38.             printf("d:%d\nf:%d\nj:%d\nk:%d\nsum:%d\n", anjian_d, anjian_f, anjian_j, anjian_k, anjian_sum);
39.         }
40.     }
42.     return 0;
43. }

复制代码

这样修改后的代码使用GetAsyncKeyState函数来检测按键状态，当某个按键被按下时，对应的计数器增加，并打印输出结果。请注意，GetAsyncKeyState函数在窗口失去焦点时也能正常工作。

球一个最佳答案谢谢啦！这对我非常重要！

Sorawithcat

isdkz 发表于 2023-10-11 07:33
可以使用GetForegroundWindow和GetFocus函数来获取当前窗口是否失去焦点，如果失去焦点就不再检测按键。同 ...

我的意思是失去焦点的时候也能获取

Sorawithcat

Mike_python小 发表于 2023-10-11 07:35
对于需要在窗口失去焦点时检测按键的需求，可以使用Windows API函数来实现。你可以使用GetAsyncKeyState函 ...

这样如果持续按键变量会一直增加

Sorawithcat

陶远航 发表于 2023-10-11 07:34
在Windows环境下，GetKeyState函数可以用来检测键盘的按键状态，包括当窗口失去焦点时的按键状态。但是，Ge ...

按下按键之后没反应