软件工程 3：模块化设计 |
您所在的位置：网站首页 › 模型设计理念怎么写简单一点 › 软件工程 3：模块化设计 |
软件工程 3：模块化设计
|
文章目录
软件工程 3面向过程：模块化设计模块设计原则：高内聚、低耦合函数设计：不知道如何下手怎么办错误处理：每个函数都有错误处理模块的编译和链接
面向对象：万事万物皆对象类：一组相似事物的统称对象：一个真实存在的类接口：一组相关的交互功能点定义的集合抽象类：基于类而抽象出来的，用于继承，不能被实例化为具体的对象封装：保护隐私、隔离关注点，减低复杂度继承：生物的遗传多态：指向父类的指针或引用，可以调用子类对象
软件工程 3 软件工程并不是一种科学，而且其重要性也与计算机本身并无关系。 软件工程革命是有关我们如何去思考的方式，以及我们如何去表达自己的思考的一个革命。 在第一课时，对比了【面向过程】、【面向对象】。 这一课，我们来说说他们的思想，具体的设计细节。 面向过程以【计算机】为核心，符合 CPU 顺序处理数据的流水线思路。 面向过程程序 = 算法 + 数据结构： 面向过程的程序是流水线的产品；算法是流水线；数据结构是原料；面向对象以【人】为核心，不再注重机器，而侧重于人对现实世界的观察。 您可以往周围看看，看到的是什么？ 可能是您的同事、桌子、墙、电脑、花盆；或者是电话、窗子、书本……这些都是【对象】，是吗~ 除了观察目标聚焦于【对象】外，当我们观察人类世界各种事情的运作的时候，我们也不知不觉的聚焦于【对象】。 家庭：父亲、母亲、大哥、小哥等；公司：董事长、经理、主管、员工等；国家：…人一般是按照面向对象的方式思考的，而且人类世界的运转方式通常也是按照面向对象的方式运作的。面向对象，是我们天然的视角。 面向对象程序 = 对象 + 交互： 对象：具体存在的事物；交互：事物之间的链接；在工业系统中，面向过程的流水线工艺以【效率】著称，一环套一环非常高效，可灵活性却不好。 一条流水线从建成开始，接下来几年甚至十几年生产的都是同一产品。 但对于软件系统来说，一款软件可能因为增加新功能、需求的变更，每年都要扩展多次…如果用流水线工艺，由于每次需求的变更，流程里的每一步骤、一环套一环，哪怕只是更改了某一环，整个流水线都得重新调整一下。 一想到是这样的情况，头就大了。这就是一个无底洞呀，小型项目还好，要是大项目，每更改一次，软件出现 bug 的概率就大几分。 所以，所以，就有了【面向对象】来解决这个问题，其实就是比较灵活（术语叫“可扩展性”）。 面向对象，适合用于经常变化的地方。 对于软件开发来说，可变的通常集中于客户需要，不变的是计算机系统的基础。 操作系统、数据库、各种协议，它们相对稳定，用【面向过程】更贴切；企业应用、互联网、游戏，需求经常变更、功能不断扩展的，用【面向对象】才适合。
虽然可扩展性，只是其中之一。 但足够了，如同法师、射手主伤害，坦克主防御，辅助主增益一样，面向对象主敏捷。 了解面向对象的特点，是应用面向对象的关键。千万不要拿把锤子，看什么都是钉子。 面向过程、面向对象都有它们的局限性，也有在各自很优秀的指标。 面向过程：模块化设计 背景：鲁滨孙漂流记。 环境：无人小岛。 目标：做一碗杂酱面。 某天鲁滨孙心血来潮，想吃一碗杂酱面了。 于是，他花了2年时间做这碗杂酱面：
原来吃一碗杂酱面是这么幸福，回想我们想吃杂酱面，只需要在手机点几下就好啦。 为什么我们想吃一碗杂酱面，就这么容易呢？ 因为平等，带来了合作，而整个社会的分工合作带来了群体演化速度加快。
面向过程之所以这么高效，就是因为【分而治之】的思想。 把一个项目，分成不同的模块，不同模块交给了不同的人；大家分工协作就能快速实现这碗杂酱面。 模块化编程的特点： 分工实现，适合多人协作；便于维护、管理、移植；对于黑客来说，懂模块化编程，对以后分析系统、底层项目是很有意义的，也是大型项目开发的基石。 模块设计原则：高内聚、低耦合 有一个梦想，定居：【苏州】。 因为我是一个面痴，每天早上能吃一碗汤面，我就很开心啦。 苏州的汤面最考究的是面汤（汤也炒鸡好喝），汤要清而不油，味要鲜而食后口不干。 我最喜欢的做法：汤是汤，面是面，先煮好面，而后把面在配好的清汤里过一下，端上来的时候也不烫。
正如上图的面，汤是汤、面是面、大排是大排（配料），这也是模块的高内聚、低耦合。 高内聚：汤是汤、面是面、大排是大排（配料），相互独立；低耦合：面与汤之间关联很少，一眼就能清晰的看出面和汤来。
模块化编程的核心思想，即【分而治之】。 所以，模块之间一定要界限分明（内聚：模块各元素的关联程度），自己的功能自己实现，不麻烦其它模块。 那如何实现高内聚呢？ 功能尽可能单一，一个函数只实现一个功能，函数的源代码行数一般不超过100行；一个模块实现一个功能，尽可能使用本模块的函数，不要麻烦其它模块；耦合：模块间的数据传递、控制高系、调用高系的关联。 耦合度越高，耦合性越强，模块独立性就越菜。 耦合方式分为（实际更多）： 非直接耦合: 两个模块之间没直接联系数据耦合: 通过参数来交换数据标记耦合: 通过参数传递记录信息控制耦合: 通过标志、开关、名字等，控制另一个模块外部耦合: 所有模块访问同一个全局变量耦合越低，维护就越方便。如果模块之间，我可以调用你，你也可以调用我… 整个程序的关系会较乱，修改、添加一个模块，牵一发动全身，所以你先得要理清这个关系，那是很头疼的。 避免高耦合，常用的设计方法： 少用全局变量，通过接口访问；禁止相互调用，只能单向调用，上下级关系；多用接口设计，接口是唯一的调用方式；如我们去餐厅，也只会和服务员（唯一接口）打交道，不会和厨房人员交流的。高内聚导致低耦合，低耦合就意味着高内聚。 内聚:模块内各元素之间的关联交互 耦合:模块间的依赖关联、交互关系 函数设计：不知道如何下手怎么办 我们实现程序里的算法时，其实就是写一个或者若干个函数。 有时候，我也不知道该如何下手。 没关系，我可以分析一下问题： 应该传什么参数给函数（作为输入参数）函数处理完后，应该把什么数据作为结果返回（作为输出参数）返回类型 函数名(函数参数) 一步步走，对一道问题完全没想法时，多半是没有分析好，这时候反复要分析。 分析好以后，知道就知道该用什么知识对答，这时候考验的是编程能力了，分析考验的是算法能力，当写好了主函数模版，接下来就思考实现某个算法的原型是怎样的，反复练习让其成为一种习惯。 加油！ 我觉得参数设计是在原型设计里最主要的，设计的好，程序简洁，递归可以避免因多层函数参数入栈而引起的爆栈。 如，二分查找的函数原型： bool binary_search( ... ); 返回是否找到，要么直接返回数的下标，要么就返回一个布尔值。 千万不要在这个子函数里面，输出：找到没找到；这样会提高模块化的耦合性，这样相当于告诉别人，我是新手中的新手。 设计参数： #define T int bool binary_search ( T arr[], T key, int len ); // arr[]：被查找的数组 // key: 查找的值 // len: 被查找数组的长度参数虽然正确，不过也并不好。 因为查找是不需要修改目标数据(被查找的数组)，没有保护数据，所以加上 const 关键字让数据不能被修改。 key和len，运行时，因为是传值，会创建(占空间)副本给形参，我们可以改成传引用减少不必要的空间。 但如何数据量巨大，采用引用会影响效率因为引用是间接寻址，传值是直接寻址所以速度比引用、指针快。 #define T int bool binary_search ( const T arr[], const T& key, const int& len ); // 算法不需要修改数据时，都应设计为 不可修改类型，这样的设计原则其实非常敏捷 // 传引用避免形参拷贝还可以简化接口，如把数组长度的参数去掉： #define T int const int len = 10; bool binary_search ( const T (&arr)[len], const T& key ); // &是传引用，(&arr)[len]是传数组的引用，可以检查数组是否溢出，只接收 len 个元素的数组。 // 如果传进来的数组，这个数组的元素个数不等于len（10），编译就不过。从侧面避免数组溢出，但引用是C++支持的，C并不支持这种写法。错误处理：每个函数都有错误处理 确定好了函数的原型之后，紧接着在完成这个函数的功能一开始的地方，就需要严格判断函数输入参数的合法性(防黑客)。 函数参数中的指针是否为NULL；if( ptr == NULL || *ptr == '\0‘ ) 函数参数中缓存的长度是否在合理范围；if( len if( finshied ) goto err_1; // 一定是往 return 方向跳 if( finshied ) goto err_2; /* goto语句 和 err的标签 之间 不能有 定义变量的操作。如 int a = 9, 但声明可 int a */ return 1; err_1: do something; // 只能调到当前函数, err 一般在函数分界处 err_2: do something; } 还可以更美好，自制一个宏。 #define check(A, M, ...) if(!(A)) {\ log_err(M, ##__VA_ARGS__); errno=0; goto error; }check宏的使用方式，和库函数assert()一样，都是断言（断言括号里的表达式为真，程序能正常运行）。 否则，【打印错误信息】并跳转到【错误标签】error处，清理。 #define T int bool binary_search ( const T arr[], const T& key, const int& len ) { check( len > 0, "参数len必须大于0"); // 断言，程序正常运行，那 len 就大于 0； // 如果断言失败，就打印错误信息（参数len必须大于0）； // 而后跳转到 error 标签，清理。 error: do something; return false; }我有许多这样，用于错误处理的宏，十分方便。 我还为这些错误处理宏，加上了颜色，输出错误信息时很美观哒。 这套错误处理宏真的好玩，像苏州面一样，要是每天都能接触到，实在是太开心啦。 这套宏，也分享给远方的你。 错误处理模块：自动化错误处理、实现异常机制 #include #include /* 调用 errno */ #include /* 调用 strerror() */ #define clean_errno() (errno == 0 ? "None" : strerror(errno)) // 看懂这句代码，需要了解 errno、strerror() // errno 是一个数字，errno = 1 是操作不允许，errno = 2 是没有这样的文件或目录，在 errno.h 文件里一共定义了 124 个常见错误 [1, 124] // errno 本身只是一个数字，如果想知道这串数字的含义是什么，可以通过 strerror() 函数，比如 errno = 2，strerror(errno) 会返回 【Error: No such file or directory】 #define log_err(M, ...) fprintf(stderr,\ "[ERROR] (%s:%d: errno: %s) " M "\n", __FILE__, __LINE__,\ clean_errno(), ##__VA_ARGS__) // log_err相当于一个调试器，当程序出现错误时，输出 那个文件名(__FILE__)、错误的行数(__LINE__)、错误的原因(strerror(errno))，以及提示信息(这个是我们调用的时候写的) #define check(A, M, ...) if(!(A)) {\ log_err(M, ##__VA_ARGS__); errno=0; goto error; } // check(同assert)，断言check括号里的内容为真，否则打印错误信息并跳转到 error 处清理 #define check_mem(A) check((A), "内存不足。") // check_mem() 可以用于检测内存，如果 A == false，就输出【内存不足】，并进行一次跳转 int main( ) { FILE *fp = fopen("file.abc","r"); // 打开一个压根不存在的文件 if( fp == NULL ) // 因为文件不存在，所以打不开，指针为空 check(fp, "提示信息：fp == NULL呀～" ); // 使用我们的错误处理宏 check(), 语法类似 assert() int *a = (int *)malloc(19979797797984); // 申请一个编译器给不了的空间 if( a == NULL ) // 因为内存不够，所以没申请到，指针为空 check_mem(a); // 和 check() 一样，只不过不需要给提示信息了 error: // 错误处理标签, do something，如 if( fp != NULL ) free(fp), fp = NULL; if( a != NULL ) free(a), a = NULL; // 特别说明：在我们的程序里，某个函数往往申请了不止一个空间 // 如果有一个空间申请失败，我们就 return -1 的话，那前面申请的空间就还没释放 // 所以，释放空间最好使用 goto 统一处理 return -1; // 如果写 return 占位，那函数就结束了 // 特别补充：这种统一错误标签（只有一个error标签）其实不灵活。 // 因为错误处理也可以检测异常，如果某个地方有问题，那程序跳过这个地方即可，接着运行下面的代码，比如上面的代码，就因为打不开文件，所以程序越过申请空间这步，直接返回了。 // 使用多个错误处理标签就可以实现异常 /* 异常应该写成这样 * if( fp == NULL ) * goto err_1; * * err_1: * do something. * * // fp有问题，没关系，接着运行 * * if( a == NULL ) * goto err_2; * * err_2: * do something * * P.S. 如果代码出错了，可能是 goto err_i语句 和 err_i 的标签 之间有【定义变量】。如 int a = 9, 这是不可以的，但声明可 int a */ fclose(fp); fp = NULL; free(a); a = NULL; return 0; }check 宏类似 assert，都是断言为真，只不过功能更加丰富，为出错处理而设计的。 goto 只能实现函数内部的跳转，不能实现跨函数跳转。 在一些错误处理中，在一个深度嵌套的函数调用中发生了错误，需要放弃当前任务，从多层函数调用中返回，并且在较高层级的函数中继续执行（或许是在 main() 函数中）。 要做到这一点，可以让每个函数都返回一个状态值，由函数的调用者检查并做相应处理，不过一层层的检查比较麻烦，setjmp 宏和 longjmp 函数 可以实现【非本地局部跳转】，也就是跨函数跳转。 无论使用什么样的错误处理方式，都不要忘记发现程序中错误的最好方法其实是执行程序，对代码进行逐条跟踪，这样可以【观察数据在函数中的流动】，同时【检查出类似于上溢和下溢错误】、【数据转换错误】、【NULL 指针错误】、【错误的内存单元】、【用 = 代替 ==】、【运算优先级错误】、【逻辑运算】等错误。 模块的编译和链接 /* 当前源文件：demo.c */ #include int main(){ printf("hello, world!"); } 上面程序的作用是打印 hello, world，在编译器里我们只要点【运行】就能看到结果。 但不同文件里的模块到底是怎么链接在一起的？ 我们为什么可以在当前源文件 main() 里，直接调用 printf()。 这就得从源代码生成可执行文件的内部机理聊起啦。
从源代码生成可执行文件可以分为四个步骤： 预处理（Preprocessing）：处理那些源文件和头文件中以#开头的命令，比如 #include、#define、#ifdef。 将所有的#define删除，并展开所有的宏定义。处理所有条件编译命令，比如 #if、#ifdef、#elif、#else、#endif 等。处理#include命令，将被包含文件的内容插入到该命令所在的位置，这与复制粘贴的效果一样。删除所有的注释 //、/* … */。添加行号和文件名标识，便于在调试和出错时给出具体的代码位置。保留所有的#pragma命令，因为编译器需要使用它们。预处理的结果是生成【.i文件】。 【.i文件】也是包含C语言代码的源文件，只不过所有的宏已经被展开，所有包含的文件已经被插入到当前文件中。 当你无法判断宏定义是否正确，或者文件包含是否有效时，可以查看【.i文件】来确定问题。 在 GCC 中，可以通过下面的命令生成.i文件： gcc -E demo.c -o demo.i // -E表示只进行预编译。 编译（Compilation）：将预处理完的文件进行词法分析、语法分析、语义分析以及优化后生成相应的【汇编代码文件】。 在 GCC 中，可以使用下面的命令生成.s文件： gcc -S demo.i -o demo.s 汇编（Assembly）：将汇编代码转换成可以执行的机器指令。 汇编的结果是产生【目标文件】，在 GCC 下的后缀为.o。 链接（Linking）：目标文件已经是二进制文件，与可执行文件的组织形式类似，只是有些函数和全局变量的地址还未找到，程序不能执行。链接的作用就是找到这些目标地址，将所有的目标文件组织成一个可以执行的二进制文件。 面向对象：万事万物皆对象 我是从 C 语言入门的，感觉很 nice !! 而后开始接触数据结构，用面向过程的方式实现数据结构时，发现每种数据结构和它的自带算法天然是一个整体，用面向对象的方式描述是不是更适合呢？ 我觉得是，所以我去学了一下 C++。 初次接触C++，我编程还没习惯从面向过程转为面向对象，感觉很别扭… 还有概念也太抽象了，只是用一些词来解释另一些词。 语言本身就有二义性，不类比、举例的话，很难理解到这一视角下的世界观。 类：一组相似事物的统称 分门别类，也是科学研究的基本方法和途径。 人类在认识客观世界的过程就是采用了分类的方法。 世界分为： 生物和非生物；生物分为 动物 植物 微生物等等；或者是 界 门 纲 目 科 属 种。面向对象的类，与古语上的【物以类聚，人以群分】的类、分门别类的类是相同的。 因此，当我们在定义什么才是“类”的时候，其实完全不需要和面向对象扯上关系。 类是【一组】【相似】事物的【统称】。 一组：在于多个，因为单个事物无法此外类；相似：人类是一个类，但每个人都是不一样的、独一无二的；统称：能够概括多个事物，每个人都可以统称为“人”、“男人或者女人”，但名字不是一个统称。对象：一个真实存在的类 在程序里，类只是一个模板（Template），编译后不占用内存空间，所以在定义类时不能对成员变量进行初始化，因为没有地方存储数据。 只有在创建对象以后才会给成员变量分配内存，这个时候就可以赋值了。 这是因为类是抽象出来的，不是真实存在的。 比如，我们说人、人类、男人、女人这些类时，它们只是一个抽象的概念，其实有没有这个人呢，是没有的。 但要说，牛顿、爱因斯坦，这些对象是真的存在的。 对象时有特点、有行为的，也就产生了数据，由此只有程序实例化对象时，编译器才会储存数据。 类是一个抽象的概念，而对象是真实存在的（类）。 接口：一组相关的交互功能点定义的集合 接口的定义比较难，名词分析： 接口：一组【相关】的【交互】功能点【定义】的【集合】； 以餐馆的列有各种菜肴的清单为例： 相关：接口中包含的功能点是相关的；各种菜肴都是为了满足口腹之欲（相关），是吧。 交互：用于不同对象的交互；客人点菜，其实是和大厨之间的交互；一个人是自嗨，不是交互。 定义：没有实现；清单里的每道菜是都可以做出来的，但客人不点，大厨是不会做的。 集合：多个；清单里可不止一个菜。 简单来说，接口就像一份列有各种菜肴的清单。 为什么要有接口呢？ 有的时候呀，我们并不知道客人想吃什么，但我们又想客人照我们的要求来活动。 这就是接口的用处所在，当您不知道一个对象所属的具体“类”，只知道这些对象都具备某种功能。 接口：一组相关的交互功能点定义的集合。 抽象类：基于类而抽象出来的，用于继承，不能被实例化为具体的对象 从设计的角度来看，抽象类是更高层次的抽象。 如果说普通类是从现实对象抽象出来的，那么抽象类就是基于类而抽象出来的。 有了类，为什么还要抽象类？ 为什么设计一种只能继承，不能实例化的类？ 答案就在于：在某些场景下普通类不够用。 例如，“苹果”、“橘子”、“香蕉”都是一个类，它们都是“水果”，这里的“水果”就是一个【抽象类】。 您可以说喜欢吃“水果”，但您真正吃“水果”的时候，要么是“苹果”，要么是“橘子”，要么是“香蕉”……但您绝不可能真正吃到一个叫作“水果”的东西。 从实现的角度来看，抽象类与普通类不同的地方在于： 抽象类有的存在抽象方法（方法只有声明，没有定义），子类必须自己定义这些抽象方法，而不能像普通的方法一样，通过继承就可以获得父类的方法。从这一点来看，抽象类和接口有点类似。 那抽象类和接口有什么区别？ 为什么有了接口，还要有抽象类？ 因为， 抽象类本质上还是类，强调一组事物的相似性，包括属性和方法的相似性；而接口只强调方法的相似性，并且仅仅体现在方法声明上的相似性，而没有方法定义上的相似性。例如。假设我们设计一个游戏，其中使用“苹果”、“橘子”、“香蕉”来做“补血”, “苹果”、“橘子”、“香蕉”都有“颜色”和“重量”这样的属性，但每种水果的补血方式是不一样的。 在这种情况下，使用抽象类可以很好地表达，我们设计一个抽象类“水果”，将“颜色”、“重量”作为“水果”的属性，“获取颜色”、“获取重量”、“减少重量”等方法作为“水果”的方法，将“补血”作为“水果”的抽象方法。这样设计能够大大减少“苹果”、“橘子”、“香蕉”几个普通类的实现工作量，它们只需要实现“补血”方法，其他的属性和方法都只需继承“水果”类即可（代码复用）。 而如果采用接口的方式实现，则“苹果”、“橘子”、“香蕉”每个类都需要自己增加“颜色”、“重量”属性，增加“获取颜色”、“获取重量”、“减少重量”、“补血”等方法，工作量和代码量大大增加。 如上分析，抽象类是一个介于类和接口之间的概念，同时具备类和接口的部分特性。 抽象类：基于类而抽象出来的，用于继承，不能被实例化为具体的对象 封装：保护隐私、隔离关注点，减低复杂度 封装的好处举个例子就明白了。 我们的房子是类的实例（对象），室内的装饰与摆设只能被它的主人欣赏、使用，如果没有四面围墙的遮挡，室内所有人的活动就暴露无疑。 所以，房子这个对象必须加上封装（四面围墙），嘿嘿，不然晚上活动会影响别人的… public: 不封装，公开的 protected: 对外不公开，但对家人(子类)公开 private：私有的，每个人都有自己的小秘密是不能告诉任何人的需要保密的时候，用封装。 继承：生物的遗传 继承本身很好理解，和我们日常生活中的“继承”概念基本一样：子承父业！所以，我们可以看到在面向对象的编程语言里面，有了“父类”、“子类”的概念。 但是我个人认为“继承”这个说法并不确切，一般我们理解“继承”都是继承产业、继承财产。 但在面向对象的领域中，并不是“子类”继承了“父类”的产业，而是继承了“父类”的特点，具体来说，就是继承了“属性“和”方法“。 所以，我认为“继承”更加贴切的说法是类似生物学上的“遗传”，按照中国话的说法就是“龙生龙，凤生凤，老鼠生来会打洞”，面向对象的继承意味“子类”遗传了 “父类”的某些属性和方法。 但就像生物学上的进化论一样，有遗传就有变异，正因为有了变异，才会有新的物种产生；有了变异，面向对象才出现了子类。 学好继承记住三句话（如果子类继承于父类）： 子类拥有父类非 private 的属性、功能；子类具有自己的属性和功能，即子类可以扩展父类没有的属性和功能；子类还可以以自己的方式实现父类的功能（方法重写）；继承的优点： 继承使得所有子类公共部分都放在了父类（代码复用），另外，继承可使得修改或者扩展继承而来的实现都较为容易。继承的缺点： 父类变，子类不得不变；因为父类和子类有很大联系，也增加了耦合性。对象之间有继承关系的时候，用继承。 多态：指向父类的指针或引用，可以调用子类对象 如果您没有学过设计模式，我写了对于您的理解也是片面的；如果您学了设计模式，那就不用看我写的了。 所以，所以，我们跳过吧！！！ |
【本文地址】