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

于 2024-06-11 16:54:30 发布
阅读量529 收藏 9
点赞数 26
文章标签： c++ 数据结构 单片机
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hele_two/article/details/139563934
版权

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

一、特性

  1. 无限制条目
  2. 无限制层级
  3. 用户自定义条目和动作
  4. 脚本式生成菜单类

二、代码实现

(一)菜单类

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

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


/*解析脚本生成菜单*/

HeleMenu * HeleMenu::parseMenu(string bat, void (*p_display[])(string&, vector<string>&, unsigned int&), void (*p_action[])()) {
 vector<char> stack_simul; //符号栈

 vector<HeleMenu*> stack_p; //指针栈

 vector<string> stack_name; //名称栈

 HeleMenu * root = nullptr; //初始化根菜单指针

 uint8_t countAction = 0;

 for (uint8_t i = 0; i < bat.length();) {
  string name = ""; //菜单名

  uint8_t step = 0; //菜单名长，即距下次读取的步长

  char a = bat[i];

  if ('{' == a) { //有子菜单

   HeleMenu *father = nullptr;

   if (stack_p.size() > 0) { //有父菜单

    father = stack_p.back(); //弹出指针栈

   }

   if (stack_name.size() > 0) {
    name = stack_name.back(); //读取名称

   }

   HeleMenu * m1 = new HeleMenu(name, father); //构建菜单

   m1->attachDisplay(p_display[countAction]);

   m1->attachAction(p_action[countAction++]);

   m1->addToMenus();

   stack_simul.push_back('{'); //压入符号栈

   stack_p.push_back(m1); //压入菜单指针

   

   i++;

  } else if ('}' == a) { //子菜单结束

   stack_simul.pop_back(); //弹出符号栈

   root = stack_p.back(); //弹出菜单指针栈

   stack_p.pop_back();

   stack_name.pop_back(); //弹出名称栈

   i++;

  } else if (',' == a) {
   i++;

  } else { //若有菜单名或值

   for (uint8_t j = i; j < bat.length() && '{' != bat[j] && '}' != bat[j] && ',' != bat[j]; j++,step++) { //读菜单名或值

    name.append(&bat[0]+j,1); //适应中文

   }

   stack_name.push_back(name);

   i += step;

   if (stack_simul.size() > 0 && '{' == stack_simul.back() && ('}' == bat[i] || ',' == bat[i])) { //若为值

    stack_p.back()->addValue(name);

   }

   

  } 

 }

 return root;

}

/*带菜单名称、父节点指针的构造函数，默认菜单名为无名，默认父节点值为空*/

HeleMenu::HeleMenu(string name, HeleMenu *p_father) {
 this->name = name;

    this->p_father = p_father;

    this->index = 0;

    this->p_action = nullptr;

    this->p_display = nullptr;

}

/*添加菜单项到菜单本*/

void HeleMenu::addToMenus() {
 if (this->p_father != nullptr) {
  this->p_father->p_childrenName.push_back(this->name); //赋予菜单内容

  this->p_father->p_children.push_back(this); //将菜单指针注册到父菜单 

 }

}

/*添加菜单单个叶节点*/

void HeleMenu::addValue(string value) {
 this->p_childrenName.push_back(value);

 this->p_children.push_back(nullptr); //添加空指针，表示无下级菜单，即叶节点

}

/*添加菜单叶节点*/

int HeleMenu::addValues(vector<string> values) {
 unsigned int i = 0;

 for (; i < values.size(); i++) {
  this->p_childrenName.push_back(values[i]); //赋予值项

  this->p_children.push_back(nullptr); //添加空指针，表示无下级菜单，即叶节点

 };

 return i;

}

  

/*添加动作回调函数*/

void HeleMenu::attachAction(void (*p_action)()) {
 this->p_action = p_action;

}

/*添加显示回调函数*/

void HeleMenu::attachDisplay(void (*p_display)(string&, vector<string>&, unsigned int&)) {
 this->p_display = p_display;

}

/*菜单响应函数*/

void HeleMenu::action() {
 this->p_action(); //回调动作函数

}

/*将某项叶节点改成对应值，实现菜单动态显示*/

void HeleMenu::changeValue(string value) {
 this->p_childrenName.at(this->index) = value;

}

/*菜单显示函数*/

void HeleMenu::display() {
 this->p_display(this->name, this->p_childrenName, this->index); //回调显示函数，1.显示内容，2.选中项

}

/*获取指定序号的子节点*/

HeleMenu * HeleMenu::getChild(unsigned int index) {
 return this->p_children.at(index);

}

/*获取某项叶节点值，实现菜单动态显示*/

string HeleMenu::getValue() {
 return this->p_childrenName.at(this->index);

}

/*删除菜单所有节点*/

void HeleMenu::removeAllItem() {
 for(auto i:this->p_children) { //释放子节点内存

  free(i);

 }

 this->p_childrenName.clear();

 this->p_children.clear();

 this->index = 0; //序号防越界，恢复默认值

}

（二）菜单浏览器类

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

/*

菜单浏览器类

(c)hele 2024

菜单浏览器主要负责菜单结构的浏览

*/

class HeleMenuViewer {
 private:

  static HeleMenu *p_rootMenu, *p_currentMenu; //内置根菜单指针、当前菜单项指针

 public:

  static void init(HeleMenu *p_rootMenu); //初始化函数

  static HeleMenu * getCurrentMenu(); //获取当前菜单指针

  static HeleMenu * getRootMenu(); //获取根菜单指针

  static void gotoFather(); //跳转到父菜单

  static void gotoChild(); //跳转到子菜单，序号指示在菜单类里

  static void gotoChild(unsigned int index, unsigned int selected=0); //跳转到指定序号的菜单，默认其选中子菜单第0项

  static void gotoRoot(); //跳转到根菜单

  static void selectUp(); //向上选择

  static void selectDown(); //向下选择

  static void action(); //当前菜单响应

  static void display(); //显示当前菜单

};
/*初始化菜单管理类的内置根菜单和当前菜单指针为空指针*/
HeleMenu *HeleMenuViewer::p_rootMenu = nullptr;
HeleMenu *HeleMenuViewer::p_currentMenu = nullptr;

/*当前菜单响应*/
void HeleMenuViewer::action() {
    p_currentMenu->action();
}
/*显示当前菜单*/
void HeleMenuViewer::display() {
    p_currentMenu->display();
}

/*获取当前菜单指针*/
HeleMenu * HeleMenuViewer::getCurrentMenu() {
    return p_currentMenu;
}

/*获取根菜单指针*/
HeleMenu * HeleMenuViewer::getRootMenu() {
    return p_rootMenu;
}

/*跳转到父菜单*/
void HeleMenuViewer::gotoFather() {
    if (p_currentMenu->p_father != nullptr) {
        p_currentMenu = p_currentMenu->p_father;    
    }
}

/*跳转到子菜单，序号指示在菜单类里*/
void HeleMenuViewer::gotoChild() {
    if (p_currentMenu->p_children.size() > 0 && p_currentMenu->p_children[p_currentMenu->index] != nullptr) { 防止无子项
        p_currentMenu = p_currentMenu->p_children[p_currentMenu->index];
    }
}

/*跳转到指定序号的菜单，默认其选中子菜单第0项*/
void HeleMenuViewer::gotoChild(unsigned int index, unsigned int selected) {
    if (index < p_currentMenu->p_children.size()) { //防止越界
        p_currentMenu->index = index; //更新菜单指示位置
        gotoChild();
        if (selected < p_currentMenu->p_children.size()) {
            p_currentMenu->index = selected;
        }
    }
}

/*跳转到根菜单*/
void HeleMenuViewer::gotoRoot() {
    p_currentMenu = p_rootMenu;
}

/*初始化函数，为根菜单指针赋值*/
void HeleMenuViewer::init(HeleMenu *p_rootMenu) {
    HeleMenuViewer::p_rootMenu = p_rootMenu;
}

/*向下选择*/
void HeleMenuViewer::selectDown() {
    if (p_currentMenu->p_childrenName.size() > 0) { //防除0错误
        p_currentMenu->index = (p_currentMenu->index + 1) % p_currentMenu->p_childrenName.size();
    }
}

/*向上选择*/
void HeleMenuViewer::selectUp() {
    if (p_currentMenu->p_childrenName.size() > 0) { //防除0错误
        p_currentMenu->index = (p_currentMenu->index - 1 + p_currentMenu->p_childrenName.size()) % p_currentMenu->p_childrenName.size();
    }

}

(三)库的生成

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

##静态库生成与调用，用HeleMenu.cpp生成库##
#编译生成.o链接文件
g++ -c HeleMenu.cpp

#利用.o文件生成静态库，文件名必须以lib***.a形式命名
ar -crv libHeleMenu.a HeleMenu.o

#调用静态库生成目标程序
g++ -o main.exe CreateAndShowMenu.cpp -L . -lHeleMenu
g++ CreateAndShowMenu.cpp libHeleMenu.a -o main.exe
-------------------------------------------------
##动态库生成与调用，用HeleMenu.cpp生成库##
#生成.o链接文件
g++ -c HeleMenu.cpp

#利用.o文件生成动态库，文件名必须以lib***.so形式命名
g++ -shared -fpic -o libHeleMenu.so HeleMenu.o

#调用动态库生成目标程序
g++ -o main.exe CreateAndShowMenu.cpp -L . -lHeleMenu
g++ CreateAndShowMenu.cpp libHeleMenu.so -o main.exe

-------------------------------------------------
代码编译优化
-O0 禁止编译器优化，默认此项
-O1 尝试优化编译时间和可执行文件大小
-O2 更多的优化，尝试几乎全部的优化功能，但不会进行“空间换时间”的优化方法
-O3 在-O2基础上再打开一些优化选项
-Os 对生成文件大小进行优化。会打开-O2开的全部选项，除了那些会增加文件大小的

三、使用示例

主要有2种方法实现用户自定义的菜单类，共同点是attachDisplay和attachAction所带的参数均为用户自定义的函数。

（一）手动生成

/*手动生成菜单*/
HeleMenu *m1 = new HeleMenu();
m1->attachDisplay(display_root);
m1->attachAction(action_root);
HeleMenuViewer::init(m1); //初始化根菜单
//    
HeleMenu *m2 = new HeleMenu("历史记录",m1);
m2->attachDisplay(display);
m2->attachAction(action);
m2->addToMenus();

m2 = new HeleMenu("操作",m1);
m2->addValues({"保存","不保存"});
m2->attachDisplay(display);
m2->attachAction(action_operate);
m2->addToMenus();

m2 = new HeleMenu("菜单",m1);
m2->attachDisplay(display);
m2->attachAction(action);
m2->addToMenus();
m1 = m2; //构建下一层子菜单

m2 = new HeleMenu("对比度", m1);
m2->addValues({"1", "2", "3", "4"});
m2->attachDisplay(display_compare);
m2->attachAction(action_compare);
m2->addToMenus();

m1->addValues({/*对比度,*/ "全部清除","重启","关机"/*,"校准","关于"*/});


m2 = new HeleMenu("校准",m1);
m2->addValue("确认");
m2->attachDisplay(display);
m2->attachAction(action_adjust);
m2->addToMenus();    

m2 = new HeleMenu("关于",m1);
m2->addValue("(c)hele 2024\n这是一个菜单类，可以帮助你生成自定义菜单，同时还可以设置动作");
m2->attachDisplay(display);
m2->attachAction(action);
m2->addToMenus();

HeleMenuViewer::gotoRoot();     //到达根菜单
while (true) { //启动
    system("cls");
    HeleMenuViewer::display();
    HeleMenuViewer::action();
}

（二）脚本生成

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

/*脚本生成菜单*/
void (*p_display[])(string&, vector<string>&, unsigned int&) = {/*root*/display_root, /*log*/display, /*operate*/display, /*menu*/display, /*constrast*/display_compare, /*adjust*/display, /*about*/display};
void (*p_action[])() = {/*root*/action_root, /*log*/action, /*operate*/action_operate, /*menu*/action, /*constrast*/action_compare, /*adjust*/action_adjust, /*about*/action};
HeleMenu *m1 = HeleMenu::parseMenu("{历史{},操作{save,unsave},菜单{对比度{1,2,3,4},clearAll,rePower,shutdown,校准{confirm},关于{(c)hele 2024，这是一个菜单}}}", p_display, p_action);
HeleMenuViewer::init(m1);

HeleMenuViewer::gotoRoot();     //到达根菜单
while (true) { //启动
    system("cls");
    HeleMenuViewer::display();
    HeleMenuViewer::action();
}

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

{
    log{
    },
    operate{
        save,unsave
    },
    menu{
        constrast{
            1,2,3,4
        },
        clearAll,
        rePower,
        shutdown,
        adjust{
            confirm
        },
        about{
            (c)hele 2024
        }
    }
}

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

（三）演示

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

b196569631ed42f2b1b2b628b3e1aa1b.gif

 四、不足与展望

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

五、参考资料

六、源码下载

可以使用本文章系统自带的下载链接，为防止丢失，我也准备一个备份链接：https://www.aigei.com/item/c_mian_xiang.html

hele_two
关注
  • 26
    点赞
  • 踩
  • 9
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
游戏修改器制作教程三：内存与Cheat Engine
El Psy Congroo
11-27 2万+
计算机程序所有的变量、代码都是储存在内存里的，包括游戏里那些HP、MP、金钱等，那么只要能修改内存就能自由改变玩家的HP、金钱了（当然对于网游是没用的，这些数据都储存在服务器，客户端里的只是一个副本），常见的满血、金钱无限等游戏修改器大部分就是这个原理
C++面向对象多级菜单向Arduino的移植
最新发布
hele_two的专栏
06-23 119
C++面向对象多级菜单库向Arduino的移植
java学习路线
w18377940962的博客
02-08 6254
Java 学习路线 Java 学习路线一条龙版 by 程序员鱼皮 ???? + ???? = ???????? 建议先观看视频导读：https://www.bilibili.com/video/BV1Qf4y1K7ff/ 大纲 路线特点 最新，完整一条龙的大厂 Java 学习路线，从入门到入土 同时适用于想全面学习 / 快速求职的同学，可以根据符号来定制自己的专属学习路线 给出目标、学习建议、关键知识点、最优资源以及各类资源推荐（视频、书籍、文档、项目、工具等） 鱼皮自己是 Java 开发者，融入个
android安卓源码海量项目合集打包-1
热门推荐
chenhao0568的专栏
06-11 13万+
下载地址 最后更新共计113个分类5177套源码29.2 GB。 卷 新加卷 的文件夹 PATH 列表 卷序列号为 00000200 5E7A:7F30 F:. ├─前台界面 │ ├─3D标签云卡片热门 │ │ Android TagCloudView云标签的灵活运用.rar │ │ Android 实现 标签 拖动 改变位置.rar │ │ android 流式布局和热门标签.zip │ │ ...
C++面向对象程序设计教程——课件PPT
10-19
C++是一种强大的编程语言，以其面向对象特性而闻名，它结合了过程化编程和面向对象编程的优势。在“C++面向对象程序设计教程——课件PPT”中，我们可以深入学习这一主题，由陈维兴和林小茶编著，清华大学出版社出版...
C++面向对象程序设计 经典例题 附练习题
12-22
C++是一种强大的、通用的编程语言，以其支持面向对象编程（OOP）而闻名。面向对象编程是一种设计和实现软件的方式，它强调将现实世界的问题和解决方案映射到计算机程序中的对象。本资料包“C++面向对象程序设计 经典...
c++多级菜单实现插入、删除、修改
10-08
通过以上步骤，我们可以构建一个完整的C++多级菜单系统，实现对学生信息的插入、删除和修改功能，并确保在插入新数据时正确判断其是否存在。这个项目不仅锻炼了基础的C++编程技能，还涉及到了文件操作、数据结构和...
c++面向对象高级语言程序设计.pdf
12-28
c++面向对象高级语言程序设计.pdf
C++ 面向对象示例
08-17
【C++ 语言】面向对象 ( 类定义 | 限制头文件引用次数 | 构造方法 | 析构方法 ) : https://hanshuliang.blog.csdn.net/article/details/99609557 【C++ 语言】面向对象 ( 成员函数 | 常量函数 | 友元函数 | 友元类 ...
c++面向对象设计语言
12-25
帮助老师更好的给学生进行教学，让学生更清楚易懂。是c++最重要的章节。
《C++面向对象程序设计》第2版编程题答案
02-26
这本书深入浅出地讲解了C++语言的核心概念，特别是面向对象编程（OOP）的思想和技术。第二版在第一版的基础上进行了修订和完善，更适应现代编程环境的需求，包含了更多的实践案例和编程练习。 在学习这门课程的过程...
c++面向对象程序设计语言重点难点复习题及答案-整理.pdf
09-30
面向对象程序设计语言C++重点难点复习题及答案总结 面向对象程序设计语言C++是一种功能强大且广泛应用的程序设计语言，作为一名程序员，掌握C++语言的重点难点是非常重要的。本文将对C++面向对象程序设计语言的重点...
c++面向对象程序设计答案 陈维新 林小茶
06-04
《C++面向对象程序设计答案》是陈维新和林小茶共同编著的一本教材，专注于讲解C++语言中的面向对象编程概念和技术。这本书的第三版提供了3-5章的编程题，旨在帮助读者通过实践来巩固所学的知识。在深入探讨这个主题...
C++面向对象程序设计习题集
05-04
C++面向对象程序设计习题集，主要练习面向对象思想。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。。
c++面向对象 背单词系统
12-12
《C++面向对象编程实现的背单词系统》 在计算机科学领域，编程语言是实现各种应用的核心工具。C++作为一款强大的、通用的编程语言，因其高效性、灵活性和丰富的库支持，常被用于开发复杂系统。面向对象编程（Object...
C++面向对象程序设计上机考试题库.pdf
09-30
C++面向对象程序设计上机考试题库.pdf
c++面向对象程序设计_杜茂康_课后答案[1-6章]_
07-03
c++面向对象程序设计_杜茂康_课后答案[1-6章]_

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值