键盘、鼠标控制

已于 2023-09-13 21:53:47 修改
阅读量64 收藏
点赞数
分类专栏： C++ 代码 文件资源 文章标签： c++ 青少年编程
于 2023-09-13 21:52:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2303_76153927/article/details/132794337
版权
C++ 同时被 3 个专栏收录
2 篇文章 0 订阅
订阅专栏
代码
2 篇文章 0 订阅
订阅专栏
文件资源
2 篇文章 0 订阅
订阅专栏

（C++小白的作品，别在意~）

头文件1（键盘）（MKeyBoard.hxx）

#ifndef _GLIBCXX_MKEYBOARD
#define _GLIBCXX_MKEYBOARD 1

#pragma GCC system_header
#include <windows.h>
#include <cstring>
#include <string>

#define KEY_DOWN(VK_NONAME) ((GetAsyncKeyState(VK_NONAME) & 0x8000) ? 1:0)

namespace std
{
	namespace MKeyBoard
	{
//		empty
#define MKB									0
#define MKB_								0
//		letter
#define MKB_A 								65
#define MKB_B 								66
#define MKB_C 								67
#define MKB_D 								68
#define MKB_E 								69
#define MKB_F 								70
#define MKB_G 								71
#define MKB_H 								72
#define MKB_I 								73
#define MKB_J 								74
#define MKB_K 								75
#define MKB_L 								76
#define MKB_M 								77
#define MKB_N 								78
#define MKB_O 								79
#define MKB_P 								80
#define MKB_Q 								81
#define MKB_R 								82
#define MKB_S 								83
#define MKB_T 								84
#define MKB_U 								85
#define MKB_V 								86
#define MKB_W 								87
#define MKB_X 								88
#define MKB_Y 								89
#define MKB_Z 								90
//		number
#define MKB_0 								48
#define MKB_1 								49
#define MKB_2 								50
#define MKB_3 								51
#define MKB_4 								52
#define MKB_5 								53
#define MKB_6 								54
#define MKB_7 								55
#define MKB_8 								56
#define MKB_9 								57
//		symbol
#define MKB_Comma							188
#define MKB_Dot 							190
#define MKB_Slash 							191
#define MKB_Semicolon 						186
#define MKB_SingleQuotationMarks 			222
#define MKB_OpenBracket 					219
#define MKB_CloseBracket 					221
#define MKB_Minus 							189
#define MKB_Equal 							187
#define MKB_BackSlash 						220
#define MKB_Plus0 							107
#define MKB_Minus0 							109
#define MKB_IsMultipliedBy0 				106
#define MKB_IsDividedBy0 					111
#define MKB_Dot0 							110
//		shortcut
#define MKB_F1 								112
#define MKB_F2 								113
#define MKB_F3 								114
#define MKB_F4 								115
#define MKB_F5 								116
#define MKB_F6 								117
#define MKB_F7 								118
#define MKB_F8 								119
#define MKB_F9 								120
#define MKB_F10 							121
#define MKB_F11 							122
#define MKB_F12 							123
//		direction
#define MKB_Left 							37
#define MKB_Up 								38
#define MKB_Right 							39
#define MKB_Down 							40
//		other
#define MKB_Enter 							13
#define MKB_CapsLook 						20
#define MKB_Shift 							16
#define MKB_Tap 							9
#define MKB_BackSpace 						8
#define MKB_Ctrl 							17
#define MKB_Win 							91
#define MKB_Alt 							18
#define MKB_Space 							32
#define MKB_Delete 							46
		class KeyBoardIn
		{
		private:
			bool ist;
		public:
			KeyBoardIn()
			{
				ist = true;
			}
			KeyBoardIn(bool _ist)
			{
				ist = _ist;
			}
			bool KeyIsDown(int a)
			{
				return KEY_DOWN(a);
			}
			bool CapsIsUp()
			{
				return GetKeyState(MKB_CapsLook);
			}
			bool IsFalse()
			{
				return !ist;
			}
			bool Clear()
			{
				ist = true;
			}
			operator bool()
			{
				return ist;
			}
			KeyBoardIn operator>>(char& a)
			{
				if (!ist)
				{
					return false;
				}
				while (true)
				{
					if (KeyIsDown(MKB_Ctrl)&& KeyIsDown(MKB_Z))
					{
						return false;
					}
					else if (KeyIsDown(MKB_A))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'a';
								return *this;
							}
							else
							{
								a = 'A';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'A';
								return *this;
							}
							else
							{
								a = 'a';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_B))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'b';
								return *this;
							}
							else
							{
								a = 'B';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'B';
								return *this;
							}
							else
							{
								a = 'b';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_C))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'c';
								return *this;
							}
							else
							{
								a = 'C';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'C';
								return *this;
							}
							else
							{
								a = 'c';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_D))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'd';
								return *this;
							}
							else
							{
								a = 'D';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'D';
								return *this;
							}
							else
							{
								a = 'd';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_E))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'e';
								return *this;
							}
							else
							{
								a = 'E';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'E';
								return *this;
							}
							else
							{
								a = 'e';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_F))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'f';
								return *this;
							}
							else
							{
								a = 'F';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'F';
								return *this;
							}
							else
							{
								a = 'f';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_G))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'g';
								return *this;
							}
							else
							{
								a = 'G';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'G';
								return *this;
							}
							else
							{
								a = 'g';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_H))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'h';
								return *this;
							}
							else
							{
								a = 'H';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'H';
								return *this;
							}
							else
							{
								a = 'h';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_I))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'i';
								return *this;
							}
							else
							{
								a = 'I';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'I';
								return *this;
							}
							else
							{
								a = 'i';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_J))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'j';
								return *this;
							}
							else
							{
								a = 'J';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'J';
								return *this;
							}
							else
							{
								a = 'j';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_K))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'k';
								return *this;
							}
							else
							{
								a = 'K';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'K';
								return *this;
							}
							else
							{
								a = 'k';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_L))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'l';
								return *this;
							}
							else
							{
								a = 'L';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'L';
								return *this;
							}
							else
							{
								a = 'l';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_M))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'm';
								return *this;
							}
							else
							{
								a = 'M';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'M';
								return *this;
							}
							else
							{
								a = 'm';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_N))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'n';
								return *this;
							}
							else
							{
								a = 'N';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'N';
								return *this;
							}
							else
							{
								a = 'n';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_O))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'o';
								return *this;
							}
							else
							{
								a = 'O';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'O';
								return *this;
							}
							else
							{
								a = 'o';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_P))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'p';
								return *this;
							}
							else
							{
								a = 'P';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'P';
								return *this;
							}
							else
							{
								a = 'p';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_R))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'r';
								return *this;
							}
							else
							{
								a = 'R';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'R';
								return *this;
							}
							else
							{
								a = 'r';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_S))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 's';
								return *this;
							}
							else
							{
								a = 'S';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'T';
								return *this;
							}
							else
							{
								a = 't';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_U))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'u';
								return *this;
							}
							else
							{
								a = 'U';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'U';
								return *this;
							}
							else
							{
								a = 'u';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_V))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'v';
								return *this;
							}
							else
							{
								a = 'V';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'V';
								return *this;
							}
							else
							{
								a = 'v';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_W))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'w';
								return *this;
							}
							else
							{
								a = 'W';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'W';
								return *this;
							}
							else
							{
								a = 'w';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_X))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'x';
								return *this;
							}
							else
							{
								a = 'X';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'X';
								return *this;
							}
							else
							{
								a = 'x';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_Y))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'y';
								return *this;
							}
							else
							{
								a = 'Y';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'Y';
								return *this;
							}
							else
							{
								a = 'y';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_Z))
					{
						if (CapsIsUp())
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'z';
								return *this;
							}
							else
							{
								a = 'Z';
								return *this;
							}
						}
						else
						{
							if (KeyIsDown(MKB_Shift))
							{
								a = 'Z';
								return *this;
							}
							else
							{
								a = 'z';
								return *this;
							}
						}
					}
					else if (KeyIsDown(MKB_1))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '!';
							return *this;
						}
						else
						{
							a = '1';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_2))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '@';
							return *this;
						}
						else
						{
							a = '2';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_3))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '#';
							return *this;
						}
						else
						{
							a = '3';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_4))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '$';
							return *this;
						}
						else
						{
							a = '4';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_5))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '%';
							return *this;
						}
						else
						{
							a = '5';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_6))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '^';
							return *this;
						}
						else
						{
							a = '6';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_7))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '&';
							return *this;
						}
						else
						{
							a = '7';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_8))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '*';
							return *this;
						}
						else
						{
							a = '8';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_9))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '(';
							return *this;
						}
						else
						{
							a = '9';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_0))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = ')';
							return *this;
						}
						else
						{
							a = '0';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_OpenBracket))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '{';
							return *this;
						}
						else
						{
							a = '[';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_CloseBracket))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '}';
							return *this;
						}
						else
						{
							a = ']';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_Minus))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '_';
							return *this;
						}
						else
						{
							a = '-';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_Equal))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '+';
							return *this;
						}
						else
						{
							a = '=';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_BackSlash))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '|';
							return *this;
						}
						else
						{
							a = '\\';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_Semicolon))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = ':';
							return *this;
						}
						else
						{
							a = ';';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_SingleQuotationMarks))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '\"';
							return *this;
						}
						else
						{
							a = '\'';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_Comma))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '<';
							return *this;
						}
						else
						{
							a = ',';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_Dot))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '>';
							return *this;
						}
						else
						{
							a = '.';
							return *this;
						}
					}
					else if (KeyIsDown(MKB_Slash))
					{
						if (KeyIsDown(MKB_Shift))
						{
							a = '?';
							return *this;
						}
						else
						{
							a = '/';
							return *this;
						}
					}
				}
			}
			KeyBoardIn operator>>(string& a)
				{
					char temp;
					while ((*this) >> temp)
					{
						if (temp == ' ' || temp == '\n')
						{
							return (*this);
						}
						a += temp;
					}
					return false;
				}
			KeyBoardIn getline(string& a)
			{
				while (true)
				{
					char temp;
					(*this) >> temp;
					if (temp == '\n')
					{
						return (*this);
					}
					a += temp;
				}
			}
			KeyBoardIn GetToOverChar(string& a, const char& overchar)
			{
				char temp;
				while ((*this) >> temp)
				{
					if (temp == overchar)
					{
						return (*this);
						a += temp;
					}
				}
				return false;
			}
			KeyBoardIn GetForNumber(string& a, const int& number)
			{
				char temp;
				for (int i = 0; i < number; i++)
				{
					if ((*this) >> temp)
					{
						a += temp;
					}
					else
					{
						return false;
					}
				}
				return (*this);
			}
		};
		KeyBoardIn mkbi;
		class KeyBoardOut
		{
		public:
			KeyBoardOut()
			{

			}
			void Down(int n)
			{
				keybd_event(n, 0, 0, 0);
			}
			void Up(int n)
			{
				keybd_event(n, 0, 2, 0);
			}
			void Fast(int n)
			{
				Down(n);
				Up(n);
			}
			void CapsLook()
			{
				Fast(MKB_CapsLook);
			}
			void Did(int a, int b)
			{
				Down(a); Down(b);
				Up(b);	Up(a);
			}
			void Open(int n)
			{
				Did(MKB_Win, n);
			}
			void Close()
			{
				Did(MKB_Alt, MKB_F4);
			}
			void Shift(int a)
			{
				Did(MKB_Shift, a);
			}
			void CapsToUp()
			{
				while (!mkbi.CapsIsUp())
				{
					Fast(MKB_CapsLook);
				}
			}
			void CapsToLower()
			{
				while (mkbi.CapsIsUp())
				{
					Fast(MKB_CapsLook);
				}
			}
			KeyBoardOut operator<<(char a)
				{
					switch (a)
					{
					case '0':
					case '1':
					case '2':
					case '3':
					case '4':
					case '5':
					case '6':
					case '7':
					case '8':
					case '9':
						Fast(a);
						break;
					case 'A':
					case 'B':
					case 'C':
					case 'D':
					case 'E':
					case 'F':
					case 'G':
					case 'H':
					case 'I':
					case 'J':
					case 'K':
					case 'L':
					case 'M':
					case 'N':
					case 'O':
					case 'P':
					case 'Q':
					case 'R':
					case 'S':
					case 'T':
					case 'U':
					case 'V':
					case 'W':
					case 'X':
					case 'Y':
					case 'Z':
						CapsToUp();
						Fast(a);
						break;
					case 'a':
					case 'b':
					case 'c':
					case 'd':
					case 'e':
					case 'f':
					case 'g':
					case 'h':
					case 'i':
					case 'j':
					case 'k':
					case 'l':
					case 'm':
					case 'n':
					case 'o':
					case 'p':
					case 'q':
					case 'r':
					case 's':
					case 't':
					case 'u':
					case 'v':
					case 'w':
					case 'x':
					case 'y':
					case 'z':
						CapsToLower();
						Fast(a - 32);
						break;
					case ' ':
						Fast(MKB_Space);
						break;
					case '!':
						Shift(MKB_1);
						break;
					case '@':
						Shift(MKB_2);
						break;
					case '#':
						Shift(MKB_3);
						break;
					case '$':
						Shift(MKB_4);
						break;
					case '%':
						Shift(MKB_5);
						break;
					case '^':
						Shift(MKB_6);
						break;
					case '&':
						Shift(MKB_7);
						break;
					case '*':
						Shift(MKB_8);
						break;
					case '(':
						Shift(MKB_9);
						break;
					case ')':
						Shift(MKB_0);
						break;
					case '-':
						Fast(MKB_Minus);
						break;
					case '=':
						Fast(MKB_Equal);
						break;
					case '[':
						Fast(MKB_OpenBracket);
						break;
					case ']':
						Fast(MKB_CloseBracket);
						break;
					case '\\':
						Fast(MKB_BackSlash);
						break;
					case ';':
						Fast(MKB_Semicolon);
						break;
					case '\'':
						Fast(MKB_SingleQuotationMarks);
						break;
					case ',':
						Fast(MKB_Comma);
						break;
					case '.':
						Fast(MKB_Dot);
						break;
					case '/':
						Fast(MKB_Slash);
						break;
					case '_':
						Shift(MKB_Minus);
						break;
					case '+':
						Shift(MKB_Equal);
						break;
					case '{':
						Shift(MKB_OpenBracket);
						break;
					case '}':
						Shift(MKB_CloseBracket);
						break;
					case '|':
						Shift(MKB_BackSlash);
						break;
					case ':':
						Shift(MKB_Semicolon);
						break;
					case '\"':
						Shift(MKB_SingleQuotationMarks);
						break;
					case '<':
						Shift(MKB_Comma);
						break;
					case '>':
						Shift(MKB_Dot);
						break;
					case '?':
						Shift(MKB_Slash);
						break;
					case '\n':
						Fast(MKB_Enter);
						break;
					}
					return *this;
				}
			KeyBoardOut operator<<(string a)
			{
				for (int i = 0; i < a.length(); i++)
				{
					(*this) << a[i];
				}
				return *this;
			}
		};
		KeyBoardOut mkbo;
		class KeyBoard : public KeyBoardIn, public KeyBoardOut
		{
		public:
			KeyBoard()
			{

			}
		};
		KeyBoard mkb;
	}
}

#endif

（不对，#define似乎能改成enum ……）

2.（鼠标）

（MMouse.hxx）

#ifndef _GLIBCXX_MMOUSE
#define _GLIBCXX_MMOUSE 1

#pragma GCC system_header

#include<windows.h>
#include<winuser.h>
#include<iostream>
#include<string>
namespace std
{
	namespace MMouse
	{
		void sleep(unsigned long long Time)
		{
			Sleep(Time);
		}
		
		enum LorR
		{
			Left,
			Right
		};
		class Mmouse
		{
		public:
			Mmouse()
			{

			}
			POINT GetXY()
			{
				POINT P;
				GetCursorPos(&P);
				return P;
			}
			Mmouse GetXY(int* x, int* y)
			{
				*x = GetXY().x;
				*y = GetXY().y;
				return *this;
			}
			Mmouse GetXY(int& x, int& y)
			{
				x = GetXY().x;
				y = GetXY().y;
				return *this;
			}
			Mmouse GetXY(POINT* P)
			{
				GetCursorPos(P);
				return *this;
			}
			Mmouse GetXY(POINT& P)
			{
				GetCursorPos(&P);
				return *this;
			}
			Mmouse SetXY(const int x, const int y) const
			{
				SetCursorPos(x, y);
				return *this;
			}
			Mmouse SetXY(const POINT P) const
			{
				return SetXY(P.x, P.y);
			}
			Mmouse Down(const int x, const int y, const LorR LR = Left) const
			{
				if (LR == Left)
				{
					mouse_event(MOUSEEVENTF_LEFTDOWN, x, y, 0, 0);
				}
				else
				{
					mouse_event(MOUSEEVENTF_RIGHTDOWN, x, y, 0, 0);
				}
				return *this;
			}
			Mmouse Down(const POINT P, const LorR LR = Left) const
			{
				Down(P.x, P.y, LR);
				return *this;
			}
			Mmouse Down(const LorR LR = Left)
			{
				POINT tP = GetXY();
				Down(tP.x, tP.y, LR);
				return *this;
			}
			Mmouse Up(const LorR LR = Left)
			{
				POINT tP = GetXY();
				if (LR == Left)
				{
					mouse_event(MOUSEEVENTF_LEFTUP, 0, 0, 0, 0);
				}
				else
				{
					mouse_event(MOUSEEVENTF_RIGHTUP, 0, 0, 0, 0);
				}
				return *this;
			}
			Mmouse Fast(const int x, const int y, const LorR LR = Left)
			{
				Down(x, y, LR);
				Up(LR);
				return *this;
			}
			Mmouse Fast(const POINT P, const LorR LR = Left)
			{
				Down(P, LR);
				Up(LR);
				return *this;
			}
			Mmouse Fast(const LorR LR = Left)
			{
				Down(LR);
				Up(LR);
				return *this;
			}
			friend istream& operator>>(istream&, LorR&);
		};
		istream& operator>>(istream& in, LorR& LR)
		{
			string temp_in;
			in >> temp_in;
			if (temp_in == "Left")
			{
				LR = Left;
			}
			if (temp_in == "Right")
			{
				LR =  Right;
			}
			return in;
		}
		Mmouse mouse;
	}
}

#endif

（好似有亿点点bug……）

大家自己琢磨一下，可以吗？（来自于6年级小学生的请求……）(http://t.csdn.cn/1SkDK)

MRRlly
关注
专栏目录
鼠标键盘控制多台计算机,一个软件即可一套键盘鼠标控制多台电脑
weixin_32298151的博客
07-24 1969
有时会遇到同一桌面上两台电脑连接两副键盘、鼠标的情况。两套键鼠不仅占空间，让我的零食无处安放，还迫使我经常手动切换鼠标或者键盘来控制另一台电脑，麻烦得蛋疼。天下苦两套键鼠久矣，还好功夫不负有蛋人，终于让我发现 Synergy 这款软件可以一套键盘、鼠标控制两台甚至多台电脑。多台电脑共用一套键盘、鼠标的前提是电脑都在同一局域网内。至于判断电脑是否在同一局域网内的方法，问一下百度还是很容易知道的，文章...
如何实现一套键盘鼠标控制两台计算机（Mouse Without Borders快速上手教程）
欲买桂花同载酒的博客
07-06 1万+
当我们需要同时使用一台主机和一台笔记本的时候，如果使用两套键盘和鼠标分别操作各自的系统，非常地不便捷且非常占据桌面空间。，可以尝试移动鼠标，把鼠标移动到设备A屏幕右边边缘即可转移到设备B上使用，键盘也可以在设备B上操作。同时，两套设备还可以实现文件的。然后它会生成图下所示的界面，这个密钥有点复杂，不用该密钥。上打开该软件，如图下所示，第一次安装使用该软件的话，先点击NO。设备A和设备B都已经安装好之后，在。比较好输入的密钥，然后点击下方的。的软件，图下所示界面，点击。设备A在左边，设备B在右边。
VR项目添加键盘鼠标控制
kasteluo的专栏
11-23 1万+
VR项目添加键盘鼠标控制使用VR模版创建的项目，程序运行后，只能使用VR头盔进行交互场景，不便于调试工作，为此，在场景中添加键盘、鼠标控制功能。1 .键盘控制添加：键盘控制主要为ASDW 键控制前后和移动,具体步骤如下： 打开Editor->->Project Settings 对话框： 找到Input选项，在Axis Mappings中添加MoveForward和MoveRight事
一套键盘鼠标控制两台电脑 Mouse Without Borders
三人行必有我师
03-18 1325
有两台电脑，一台笔记本一台台式机，拥有各自拥有鼠标和键盘，但总是需要切换，感觉太麻烦，想找个简单的方式，不需要额外操作就能同时操作这两台电脑。无意间发现了一个微软软件Mouse Without Borders，能同时控制两台电脑满足我的需求。1、能和屏幕扩展一样，使用单个鼠标和键盘无缝控制多台计算机。2、根据下载文件进行安装，傻瓜式安装，一步步向下就好了。控制电脑的 Security Key 两台电脑需要一致。2、点多点系统：任何机器都可以成为主机。有其他亮点待发现，但已满足我现在需求。
鼠标键盘控制c++
asdfasfddsfasdf的博客
08-18 1849
把单击左键的代码中的“LEFT”换成“RIGHT”就可以了（记得每一个字母都要大写，我就有写成小写报错不知道错哪的经历）键　　 键码　 　键　　 键码　　　 键　　 键码 　　 键　　　　键码。控制鼠标移动的代码，配合点击可以完成许多好玩的东西。Sleep是等待的代码，以毫秒为单位。感觉鼠标控制挺好玩的。
Cesium 键盘鼠标控制相机漫游（源码+原理讲解）
GISer小辉
12-21 2633
cesium实现键盘鼠标控制相机漫游功能，全网唯一带详细原理讲解
基于qt的键盘鼠标控制
fanhenghui的专栏
08-08 2298
pro里面加配置 LIBS += user32.lib DEFINES+=_X86_ widget文件 #ifndef WIDGET_H #define WIDGET_H   #include &lt;QWidget&gt; #include &lt;QTimer&gt; namespace Ui { class Widget; }   ...
【Unity3D】键盘鼠标控制视角的移动
热门推荐
编程记录，亲测有效
05-02 4万+
在3D游戏里面，视角是一个很重要的因素，部分玩家对锁视角嗤之以鼻，因此视角也是游戏制作里面需要努力的方面。其实也不难，换到Unity3D里面是想办法控制摄像机的移动。下面举一个简单的例子说明在Unity3D如何用键盘鼠标控制视角的移动的。如下图所示： 就像大部分游戏一样，可以用鼠标滚轮控制视角的远近，键盘的wasd和上下左右控制镜头的位置，而按着鼠标右键则可以控制镜头的旋转。当然你可以根
计算机控制鼠标,键盘控制鼠标,详细教您如何使用键盘来控制鼠标
weixin_42533751的博客
07-08 4241
冬天天气寒冷，我们喜欢窝在被窝里玩电脑，此时不方便使用鼠标，能否用键盘来操作鼠标呢？一些工业电脑上，一些船载电脑上，不太方便安装鼠标，是否有软件能够将键盘操作转换为鼠标操作呢？下面，小编就来跟大家介绍使用键盘来控制鼠标的操作步骤。现如今，我们生活在科技时代，电脑成了不可或缺的部分。有时会面临这样的困境：台式电脑有键盘没有鼠标，感觉用快捷键很麻烦，这时便有一个键盘代替鼠标的的想法。然而这一想法完全可...
如何使用一套键盘鼠标，同时控制多台电脑？
王炳明
07-03 1万+
1. 蓝牙键盘 我使用的蓝牙键盘是 GANSS GS87键的蓝牙双模键盘茶轴，既支持有线，也支持无线。最大的优点是便宜，到手 300 多，这个价格能买到有牌子、质量还不错的机械键盘算是非常难得的。当然也有一点小瑕疵，就是不能充电，得用电池，不过大半年才换一次电池，这个缺陷也可以忽略了。 接下来记录一下该键盘的蓝牙连接的设置步骤，其他键盘应该也是同理，希望能给大家一些参与： 先选择你要设置的键：比如你想把 Fn+Q，作为切换到 Mac 的快捷键，那么你先按 Fn + Q，表示已经进入这个快捷键的作用域下。
USB硬件 键盘鼠标控制器 Lao-UKM V3.1 易语言串口通讯简单例子 .
07-03
USB硬件 键盘鼠标控制器 Lao-UKM V3.1 易语言串口通讯简单例子 . 易语言5.11下， 9600波特率 com2 先打开端口，再发送数据， 鼠标移动命令： 02 00 f6 00 00 5位 16进制码 易语言我转换成10进制发送的：02 ...
unity 键盘鼠标控制第一人称对象
04-07
以上就是关于"unity 键盘鼠标控制第一人称对象"的相关知识点，涵盖从基本的C#脚本编程到更复杂的输入处理、摄像机控制和游戏对象的互动。理解并掌握这些知识点是创建沉浸式第一人称体验的关键。
教你在局域网中用一套键盘鼠标控制多台电脑.pdf
11-27
Synergy 是一款开源的多台电脑控制软件，允许用户在局域网中用一套键盘鼠标控制多台电脑。其主要功能包括共享鼠标、键盘、剪贴板，可以在多台电脑之间实现无缝切换。 Synergy 的主要特点包括： * 跨平台支持：...
synergy.zip_SetJob_Synergy_远程控制电脑_键盘 鼠标 控制
07-15
Synergy可以算作一款远程控制... 这样如果你有多台电脑并且每台电脑都有自己的显示器，你可以通过 Synergy 用一组键盘和鼠标控制所有电脑， 而且每台电脑的屏幕可以连接起来，就像在同一台电脑上使用多个显示器一样。
【一套键盘鼠标控制多台电脑的工具】MouseWithoutBordersSetup
11-19
一套键盘鼠标控制多台电脑的工具插件 在想要同时使用一套装备的电脑上安装，多个电脑在同一个局域网内即可，可以支持不同的操作系统。 可以根据设备的物理位置调整，鼠标移动到设备的边缘可直接挪到另一个电脑 不同...
Type-C PD诱骗取电快充协议芯片 支持PD 5V、9V、12V、15V、20V电压
xcx003的博客
11-02 601
XSP01A是一款专为Type-C接口设计的取电诱骗协议芯片，它它集成了先进的电源管理和协议控制功能，旨在为用户提供高效、安全、稳定的充电体验。该芯片集成USB Power Delivery (PD) 3.0/2.0快充协议，支持从手机充电器/车充等电源上取电给产品供电。支持最大功率100W给设备安全快速供电。综上所述，XSP01A诱骗取电协议芯片以其高效、安全、稳定的充电性能以及广泛的设备兼容性和应用场景，正在逐步改变着我们的充电体验和设备电源管理方式。
杨辉三角——c语言
最新发布
aqua3535742358的博客
11-05 499
define N 10 //自己定义输出行数。
c++中局部变量和全局变量同名，使用::访问全局变量
weixin_43845922的博客
11-02 301
局部变量可以与全局变量同名，在函数内引用这个变量时，会用到同名的局部变量，而不会用到全局变量。于有些编译器而言，在同一个函数内可以定义多个同名的局部变量，比如在两个循环体内都定义一个同名的局。答：能，局部会屏蔽全局。要用全局变量，需要使用”::”部变量，而那个局部变量的作用域就在那个循环体内。局部变量能否和全局变量重名？
C++编程法则365天一天一条（344）理解std::optional的设计初衷
二进制君
11-02 95
的设计初衷是为了解决处理可选值时的安全性和清晰性问题，提供一种简洁、易用的方式来表示和管理可能不存在的值。通过引入，C++ 提供了一个更现代化的替代方案，减少了使用传统空指针和特定标记值所带来的复杂性和错误风险。
使用DirectInput实现高效键盘鼠标控制
"directInput_鼠标键盘的应用" 在游戏开发中，交互性是至关重要的，...通过DirectInput，开发者不仅可以实现基本的键盘和鼠标控制，还可以利用其高级特性，如游戏杆和力反馈设备的支持，进一步丰富游戏的交互方式。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值