C++面向对象语言自制多级菜单

因为要做一个小应用，必要一个菜单类，在网上找了许久，也没有找到一款心仪的菜单类，索性用C++语言，自制一个下令行级别的菜单类，并制作成库，现记载下来，供以后鉴戒。
一、特性

• 无穷制条目
  
• 无穷制层级
  
• 用户自定义条目和动作
  
• 脚本式天生菜单类
  

二、代码实现

(一)菜单类

菜单类重要负责菜单的创建、修改、删除，是包含菜单结构构造和响应函数的模子，用户拥有充实的自主性，可根据必要自定义菜单显示和响应函数。其中菜单项利用vector容器数据结构，根据用户下令可进行菜单创建、修改、删除，而显示和响应函数则利用函数指针进行生存，体现了回调函数的特性。

1. /*
2. 菜单类
3. (c) hele 2024
4. 菜单类主要负责菜单的创建、修改、删除，是包含菜单结构组织和响应函数的模型，用户拥有充分的自主性，需要自定义菜单显示和响应函数
5. */
6. class HeleMenu {
7.     private:
8.         void (*p_action)()=nullptr; //回调函数指针，菜单响应函数
9.         void (*p_display)(string &name, vector<string> &content, unsigned int &index)=nullptr;//回调函数指针，菜单显示函数
10.         
11.    
12.     public:
13.         string name; //当前菜单名称
14.         HeleMenu *p_father; //父节点指针，默认NULL        
15.         vector<string> p_childrenName; //下级菜单项名称，默认empty无下级菜单
16.         vector<HeleMenu *> p_children; //下级菜单项，默认empty无下级菜单  
17.         unsigned int index; //菜单项选择指示位，默认0      
18.                   
19.         static HeleMenu * parseMenu(string bat, void (*p_display[])(string&, vector<string>&, unsigned int&), void (*p_action[])()); //解析脚本生成菜单
20.         HeleMenu(string name = "", HeleMenu *p_father = nullptr); //带菜单名称、父节点指针的构造函数，默认菜单名为无名，默认父节点值为空
21.         void addToMenus(); //添加菜单项到菜单本
22.         void addValue(string value); //添加菜单单个叶节点
23.         int addValues(vector<string> values); //添加菜单叶节点
24.         void changeValue(string value); //修改菜单叶节点
25.         HeleMenu *getChild(unsigned int index = 0); //获取指定序号的子节点，默认第0项子节点
26.         string getValue(); //获取菜单叶节点
27.         void removeAllItem(); //删除菜单所有节点
28.         void attachAction(void (*p_action)()); //添加动作回调函数
29.         void attachDisplay(void (*p_display)(string&, vector<string>&, unsigned int&)); //添加显示回调函数 0.菜单名，1.显示内容，2.选中项
30.         void action(); //菜单响应函数
31.         void display(); //菜单显示函数
32. };

复制代码

1. /*解析脚本生成菜单*/
3. HeleMenu * HeleMenu::parseMenu(string bat, void (*p_display[])(string&, vector<string>&, unsigned int&), void (*p_action[])()) {
4. vector<char> stack_simul; //符号栈
6. vector<HeleMenu*> stack_p; //指针栈
8. vector<string> stack_name; //名称栈
10. HeleMenu * root = nullptr; //初始化根菜单指针
12. uint8_t countAction = 0;
14. for (uint8_t i = 0; i < bat.length();) {
15.   string name = ""; //菜单名
17.   uint8_t step = 0; //菜单名长，即距下次读取的步长
19.   char a = bat[i];
21.   if ('{' == a) { //有子菜单
23.    HeleMenu *father = nullptr;
25.    if (stack_p.size() > 0) { //有父菜单
27.     father = stack_p.back(); //弹出指针栈
29.    }
31.    if (stack_name.size() > 0) {
32.     name = stack_name.back(); //读取名称
34.    }
36.    HeleMenu * m1 = new HeleMenu(name, father); //构建菜单
38.    m1->attachDisplay(p_display[countAction]);
40.    m1->attachAction(p_action[countAction++]);
42.    m1->addToMenus();
44.    stack_simul.push_back('{'); //压入符号栈
46.    stack_p.push_back(m1); //压入菜单指针
48.    
50.    i++;
52.   } else if ('}' == a) { //子菜单结束
54.    stack_simul.pop_back(); //弹出符号栈
56.    root = stack_p.back(); //弹出菜单指针栈
58.    stack_p.pop_back();
60.    stack_name.pop_back(); //弹出名称栈
62.    i++;
64.   } else if (',' == a) {
65.    i++;
67.   } else { //若有菜单名或值
69.    for (uint8_t j = i; j < bat.length() && '{' != bat[j] && '}' != bat[j] && ',' != bat[j]; j++,step++) { //读菜单名或值
71.     name.append(&bat[0]+j,1); //适应中文
73.    }
75.    stack_name.push_back(name);
77.    i += step;
79.    if (stack_simul.size() > 0 && '{' == stack_simul.back() && ('}' == bat[i] || ',' == bat[i])) { //若为值
81.     stack_p.back()->addValue(name);
83.    }
85.    
87.   }
89. }
91. return root;
93. }
95. /*带菜单名称、父节点指针的构造函数，默认菜单名为无名，默认父节点值为空*/
97. HeleMenu::HeleMenu(string name, HeleMenu *p_father) {
98. this->name = name;
100.     this->p_father = p_father;
102.     this->index = 0;
104.     this->p_action = nullptr;
106.     this->p_display = nullptr;
108. }
110. /*添加菜单项到菜单本*/
112. void HeleMenu::addToMenus() {
113. if (this->p_father != nullptr) {
114.   this->p_father->p_childrenName.push_back(this->name); //赋予菜单内容
116.   this->p_father->p_children.push_back(this); //将菜单指针注册到父菜单
118. }
120. }
122. /*添加菜单单个叶节点*/
124. void HeleMenu::addValue(string value) {
125. this->p_childrenName.push_back(value);
127. this->p_children.push_back(nullptr); //添加空指针，表示无下级菜单，即叶节点
129. }
131. /*添加菜单叶节点*/
133. int HeleMenu::addValues(vector<string> values) {
134. unsigned int i = 0;
136. for (; i < values.size(); i++) {
137.   this->p_childrenName.push_back(values[i]); //赋予值项
139.   this->p_children.push_back(nullptr); //添加空指针，表示无下级菜单，即叶节点
141. };
143. return i;
145. }
147.   
149. /*添加动作回调函数*/
151. void HeleMenu::attachAction(void (*p_action)()) {
152. this->p_action = p_action;
154. }
156. /*添加显示回调函数*/
158. void HeleMenu::attachDisplay(void (*p_display)(string&, vector<string>&, unsigned int&)) {
159. this->p_display = p_display;
161. }
163. /*菜单响应函数*/
165. void HeleMenu::action() {
166. this->p_action(); //回调动作函数
168. }
170. /*将某项叶节点改成对应值，实现菜单动态显示*/
172. void HeleMenu::changeValue(string value) {
173. this->p_childrenName.at(this->index) = value;
175. }
177. /*菜单显示函数*/
179. void HeleMenu::display() {
180. this->p_display(this->name, this->p_childrenName, this->index); //回调显示函数，1.显示内容，2.选中项
182. }
184. /*获取指定序号的子节点*/
186. HeleMenu * HeleMenu::getChild(unsigned int index) {
187. return this->p_children.at(index);
189. }
191. /*获取某项叶节点值，实现菜单动态显示*/
193. string HeleMenu::getValue() {
194. return this->p_childrenName.at(this->index);
196. }
198. /*删除菜单所有节点*/
200. void HeleMenu::removeAllItem() {
201. for(auto i:this->p_children) { //释放子节点内存
203.   free(i);
205. }
207. this->p_childrenName.clear();
209. this->p_children.clear();
211. this->index = 0; //序号防越界，恢复默认值
213. }

复制代码

（二）菜单欣赏器类

菜单欣赏器类重要负责菜单结构的欣赏导航。私有变量是2个菜单类指针，1个是根目录指针，1个是当前目录指针。

1. /*
3. 菜单浏览器类
5. (c)hele 2024
7. 菜单浏览器主要负责菜单结构的浏览
9. */
13. class HeleMenuViewer {
15. private:
19.   static HeleMenu *p_rootMenu, *p_currentMenu; //内置根菜单指针、当前菜单项指针
23. public:
27.   static void init(HeleMenu *p_rootMenu); //初始化函数
31.   static HeleMenu * getCurrentMenu(); //获取当前菜单指针
35.   static HeleMenu * getRootMenu(); //获取根菜单指针
39.   static void gotoFather(); //跳转到父菜单
43.   static void gotoChild(); //跳转到子菜单，序号指示在菜单类里
47.   static void gotoChild(unsigned int index, unsigned int selected=0); //跳转到指定序号的菜单，默认其选中子菜单第0项
51.   static void gotoRoot(); //跳转到根菜单
55.   static void selectUp(); //向上选择
59.   static void selectDown(); //向下选择
63.   static void action(); //当前菜单响应
67.   static void display(); //显示当前菜单
71. };

复制代码

1. /*初始化菜单管理类的内置根菜单和当前菜单指针为空指针*/
3. HeleMenu *HeleMenuViewer::p_rootMenu = nullptr;
5. HeleMenu *HeleMenuViewer::p_currentMenu = nullptr;
9. /*当前菜单响应*/
11. void HeleMenuViewer::action() {
13.     p_currentMenu->action();
15. }
17. /*显示当前菜单*/
19. void HeleMenuViewer::display() {
21.     p_currentMenu->display();
23. }
27. /*获取当前菜单指针*/
29. HeleMenu * HeleMenuViewer::getCurrentMenu() {
31.     return p_currentMenu;
33. }
37. /*获取根菜单指针*/
39. HeleMenu * HeleMenuViewer::getRootMenu() {
41.     return p_rootMenu;
43. }
47. /*跳转到父菜单*/
49. void HeleMenuViewer::gotoFather() {
51.     if (p_currentMenu->p_father != nullptr) {
53.         p_currentMenu = p_currentMenu->p_father;   
55.     }
57. }
61. /*跳转到子菜单，序号指示在菜单类里*/
63. void HeleMenuViewer::gotoChild() {
65.     if (p_currentMenu->p_children.size() > 0 && p_currentMenu->p_children[p_currentMenu->index] != nullptr) { 防止无子项
67.         p_currentMenu = p_currentMenu->p_children[p_currentMenu->index];
69.     }
71. }
75. /*跳转到指定序号的菜单，默认其选中子菜单第0项*/
77. void HeleMenuViewer::gotoChild(unsigned int index, unsigned int selected) {
79.     if (index < p_currentMenu->p_children.size()) { //防止越界
81.         p_currentMenu->index = index; //更新菜单指示位置
83.         gotoChild();
85.         if (selected < p_currentMenu->p_children.size()) {
87.             p_currentMenu->index = selected;
89.         }
91.     }
93. }
97. /*跳转到根菜单*/
99. void HeleMenuViewer::gotoRoot() {
101.     p_currentMenu = p_rootMenu;
103. }
107. /*初始化函数，为根菜单指针赋值*/
109. void HeleMenuViewer::init(HeleMenu *p_rootMenu) {
111.     HeleMenuViewer::p_rootMenu = p_rootMenu;
113. }
117. /*向下选择*/
119. void HeleMenuViewer::selectDown() {
121.     if (p_currentMenu->p_childrenName.size() > 0) { //防除0错误
123.         p_currentMenu->index = (p_currentMenu->index + 1) % p_currentMenu->p_childrenName.size();
125.     }
127. }
131. /*向上选择*/
133. void HeleMenuViewer::selectUp() {
135.     if (p_currentMenu->p_childrenName.size() > 0) { //防除0错误
137.         p_currentMenu->index = (p_currentMenu->index - 1 + p_currentMenu->p_childrenName.size()) % p_currentMenu->p_childrenName.size();
139.     }
143. }

复制代码

(三)库的天生

网上的资料有很多了，在此仅简单记载。

1. ##静态库生成与调用，用HeleMenu.cpp生成库##
2. #编译生成.o链接文件
3. g++ -c HeleMenu.cpp
5. #利用.o文件生成静态库，文件名必须以lib***.a形式命名
6. ar -crv libHeleMenu.a HeleMenu.o
8. #调用静态库生成目标程序
9. g++ -o main.exe CreateAndShowMenu.cpp -L . -lHeleMenu
10. g++ CreateAndShowMenu.cpp libHeleMenu.a -o main.exe
11. -------------------------------------------------
12. ##动态库生成与调用，用HeleMenu.cpp生成库##
13. #生成.o链接文件
14. g++ -c HeleMenu.cpp
16. #利用.o文件生成动态库，文件名必须以lib***.so形式命名
17. g++ -shared -fpic -o libHeleMenu.so HeleMenu.o
19. #调用动态库生成目标程序
20. g++ -o main.exe CreateAndShowMenu.cpp -L . -lHeleMenu
21. g++ CreateAndShowMenu.cpp libHeleMenu.so -o main.exe
23. -------------------------------------------------
24. 代码编译优化
25. -O0 禁止编译器优化，默认此项
26. -O1 尝试优化编译时间和可执行文件大小
27. -O2 更多的优化，尝试几乎全部的优化功能，但不会进行“空间换时间”的优化方法
28. -O3 在-O2基础上再打开一些优化选项
29. -Os 对生成文件大小进行优化。会打开-O2开的全部选项，除了那些会增加文件大小的

复制代码

三、利用示例

重要有2种方法实现用户自定义的菜单类，共同点是attachDisplay和attachAction所带的参数均为用户自定义的函数。
（一）手动天生

1. /*手动生成菜单*/
3. HeleMenu *m1 = new HeleMenu();
5. m1->attachDisplay(display_root);
7. m1->attachAction(action_root);
9. HeleMenuViewer::init(m1); //初始化根菜单
11. //   
13. HeleMenu *m2 = new HeleMenu("历史记录",m1);
15. m2->attachDisplay(display);
17. m2->attachAction(action);
19. m2->addToMenus();
23. m2 = new HeleMenu("操作",m1);
25. m2->addValues({"保存","不保存"});
27. m2->attachDisplay(display);
29. m2->attachAction(action_operate);
31. m2->addToMenus();
35. m2 = new HeleMenu("菜单",m1);
37. m2->attachDisplay(display);
39. m2->attachAction(action);
41. m2->addToMenus();
43. m1 = m2; //构建下一层子菜单
47. m2 = new HeleMenu("对比度", m1);
49. m2->addValues({"1", "2", "3", "4"});
51. m2->attachDisplay(display_compare);
53. m2->attachAction(action_compare);
55. m2->addToMenus();
59. m1->addValues({/*对比度,*/ "全部清除","重启","关机"/*,"校准","关于"*/});
65. m2 = new HeleMenu("校准",m1);
67. m2->addValue("确认");
69. m2->attachDisplay(display);
71. m2->attachAction(action_adjust);
73. m2->addToMenus();   
77. m2 = new HeleMenu("关于",m1);
79. m2->addValue("(c)hele 2024\n这是一个菜单类，可以帮助你生成自定义菜单，同时还可以设置动作");
81. m2->attachDisplay(display);
83. m2->attachAction(action);
85. m2->addToMenus();
89. HeleMenuViewer::gotoRoot();     //到达根菜单
91. while (true) { //启动
93.     system("cls");
95.     HeleMenuViewer::display();
97.     HeleMenuViewer::action();
99. }

复制代码

（二）脚本天生

重要利用菜单类parseMenu函数实现，写了1个解析器，可以实现菜单类的自动天生。

1. /*脚本生成菜单*/
3. void (*p_display[])(string&, vector<string>&, unsigned int&) = {/*root*/display_root, /*log*/display, /*operate*/display, /*menu*/display, /*constrast*/display_compare, /*adjust*/display, /*about*/display};
5. void (*p_action[])() = {/*root*/action_root, /*log*/action, /*operate*/action_operate, /*menu*/action, /*constrast*/action_compare, /*adjust*/action_adjust, /*about*/action};
7. HeleMenu *m1 = HeleMenu::parseMenu("{历史{},操作{save,unsave},菜单{对比度{1,2,3,4},clearAll,rePower,shutdown,校准{confirm},关于{(c)hele 2024，这是一个菜单}}}", p_display, p_action);
9. HeleMenuViewer::init(m1);
13. HeleMenuViewer::gotoRoot();     //到达根菜单
15. while (true) { //启动
17.     system("cls");
19.     HeleMenuViewer::display();
21.     HeleMenuViewer::action();
23. }

复制代码

parseMenu所带的参数共3个，第1个是菜单结构字符串，也就是天生菜单结构的脚本，后面2个参数分别是显示函数指针数组和响应函数指针数组。为便于明白，下面我将用户自定义菜单结构展开：

1. {
2.     log{
3.     },
4.     operate{
5.         save,unsave
6.     },
7.     menu{
8.         constrast{
9.             1,2,3,4
10.         },
11.         clearAll,
12.         rePower,
13.         shutdown,
14.         adjust{
15.             confirm
16.         },
17.         about{
18.             (c)hele 2024
19.         }
20.     }
21. }

复制代码

每一个'{'都意味着该项目有子菜单，每一个'}'意味着该菜单结束，每一个','都意味着有同级菜单，以上这3个符号均是关键词，均是英文字符。全部菜单除内容中间可以有空格外，其余地方不能有多余的空格。支持中文。
（三）演示

重要利用上、下、左、右、空格、回车、退出这些按键，只实现部门功能。

四、不敷与展望

运用C++面向对象头脑进行编程，代码体积大，效率低；
利用脚本天生菜单是个新颖的思绪，但容错性不好，没有对脚本进行规范化的检查，对用户不友好；
可以利用ArduinoSTL库，将此库移植进Arduino系列单片机项目中；
利用了动态分配内存技术，对于RAM较小的单片机，容易内存溢出。
五、参考资料

• GCC编译步调、动态库和静态库的创建和利用、ELF库简介及查看方法
  
• C语言（函数指针数组）详解
  
• 字符编码详解及利用C++ STL string遍历中文字符串
  
• 自制的Arduino多级菜单类
  
• C++库文件string，vector
  

六、源码下载

• https://www.aigei.com/item/c_mian_xiang.html
  
• https://download.csdn.net/download/hele_two/89414475?spm=1001.2014.3001.5503
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。