软件耦合的分类及解决方法_软件解耦

什么是耦合、解耦

已剪辑自: https://www.cnblogs.com/zhjblogs/p/14221560.html

一、耦合（可以称为关联性）

1、耦合是指两个或两个以上的体系或两种运动形式间通过相互作用而彼此影响以至联合起来的现象。

3、分类：有软硬件之间的耦合，还有软件各模块之间的耦合。耦合性是程序结构中各个模块之间相互关联的度量。它取决于各个模块之间的接口的复杂程度、调用模块的方式以及哪些信息通过接口。

二、解耦

1、解耦，字面意思就是解除耦合关系。

之前组内同学问我耦合的关系，我没给对方讲清楚，今天借这个机会来深入讲讲模块之间的耦合关系这个事情。

本文将用图文详细讲解七种耦合的不同之处。

高内聚与低耦合

高内聚与低耦合是每个软件开发者追求的目标，那么内聚和耦合分别是什么意思呢？

内聚是从功能角度来度量模块内的联系，一个好的内聚模块应当恰好做一件事。它描述的是模块内的功能联系。

耦合是软件结构中各模块之间相互连接的一种度量，耦合强弱取决于模块间接口的复杂程度、进入或访问一个模块的点以及通过接口的数据。

耦合

不同模块之间的关系就是耦合，根据耦合程度可以分为7种，耦合度依次变低。

• 内容耦合
• 公共耦合
• 外部耦合
• 控制耦合
• 标记耦合
• 数据耦合
• 非直接耦合

下面我们来说说每种耦合是什么，开始之前先来说下要实现的功能。m1和m2是两个独立的模块，其中m2种会显示m1的输入，m1会显示m2的输入。

很显然，m1和m2两个模块之间会有一些联系（耦合），你也可以想想如何实现这个功能，下面用7种不同的方式来实现这个功能。

注：项目的代码我放到了github，项目的demo，可以在这里查看。

内容耦合

如果发生下列情形，两个模块之间就发生了内容耦合。

一个模块直接访问另一个模块的内部数据；

一个模块不通过正常入口转到另一模块内部；

两个模块有一部分程序代码重叠(只可能出现在汇编语言中)；

一个模块有多个入口。

在内容耦合的情形，所访问模块的任何变更，或者用不同的编译器对它再编译，

都会造成程序出错。好在大多数高级程序设计语言已经设计成不允许出现内容

耦合。它一般出现在汇编语言程序中。这种耦合是模块独立性最弱的耦合。

内容耦合是最紧的耦合程度，一个模块直接访问另一模块的内容，则称这两个模块为内容耦合。

为了实现功能，我们将m1的输入放到m2.m1input上，将m2的输入放到m1.m2input上。

// m1.js
root.m2.m1input = this.value;
m2.update();
 
// m2.js
root.m1.m2input = this.value;
m1.update();
1
2
3
4
5
6
7

PS:不知道谁会这么写代码，除了我为了做演示之外。。。

查看完整代码和demo。

公共耦合

若一组模块都访问同一个公共数据环境，则它们之间的耦合就称为公共耦合。公共的数据环境可以是全局数据结构、共享的通信区、内存的公共覆盖区等。 这种耦合会引起下列问题：

所有公共耦合模块都与某一个公共数据环境内部各项的物理安排有关，若修改某个数据的大小，将会影响到所有的模块。

无法控制各个模块对公共数据的存取，严重影响软件模块的可靠性和适应性。

公共数据名的使用，明显降低了程序的可读性。

公共耦合的复杂程度随耦合模块的个数增加而显著增加。若只是两个模块之间有公共数据环境，则公共耦合有两种情况。

若一个模块只是往公共数据环境里传送数据，而另一个模块只是从公共数据环境中取数据，则这种公共耦合叫做松散公共耦合。若两个模块都从公共数据环境中取数据，又都向公共数据环境里送数据，则这种公共耦合叫做紧密公共耦合。只有在模块之间共享的数据很多，且通过参数表传递不方便时，才使用公共耦合。否则，还是使用模块独立性比较高的数据耦合好些。

一组模块都访问同一个全局数据结构，则称之为公共耦合。

在这种case中，m1和m2将自己的输入放到全局的data上。

// m1.js
root.data.m1input = this.value;
m2.update();
 
// m2.js
root.data.m2input = this.value;
m1.update();
1
2
3
4
5
6
7

查看完整代码和demo。

外部耦合

一组模块都访问同一全局简单变量而不是同一全局数据结构，而且不是通过参数表传递该全局变量的信息，则称之为外部耦合。例如C语言程序中各个模块都访问被说明为extern类型的外部变量。外部耦合引起的问题类似于公共耦合，区别在于在外部耦合中不存在依赖于一个数据结构内部各项的物理安排。

一组模块都访问同一全局简单变量，而且不通过参数表传递该全局变量的信息，则称之为外部耦合。外部耦合和公共耦合很像，区别就是一个是简单变量，一个是复杂数据结构。

在这种case中，m1和m2都将自己的输入放到全局上。

// m1.js
root.m1input = this.value;
m2.update();
 
// m2.js
root.m2input = this.value;
m1.update();
1
2
3
4
5
6
7

查看完整代码和demo。

控制耦合

如果一个模块通过传送开关、标志、名字等控制信息，明显地控制选择另一模块的功能，就是控制耦合。这种耦合的实质是在单一接口上选择多功能模块中的某项功能。因此，对所控制模块的任何修改，都会影响控制模块。另外，控制耦合也意味着控制模块必须知道所控制模块内部的一些逻辑关系，这些都会降低模块的独立性。

模块之间传递的不是数据信息，而是控制信息例如标志、开关量等，一个模块控制了另一个模块的功能。

从控制耦合开始，模块的数据就放在自己内部了，不同模块之间通过接口互相调用。

在这个case中，得增加一个需求，就是当m1的输入为空时，隐藏m2的显示信息。

// m1.js
root.m1input = this.value;
m2.update();
 
m2.toggle(!!this.value); // 传递flag
1
2
3
4
5

上面的代码中m1直接控制了m2的显示和隐藏。

查看完整代码和demo。

标（印）记耦合

如果一组模块通过参数表传递记录信息，就是标记耦合。事实上，这组模块共享了这个记录，它是某一数据结构的子结构，而不是简单变量。这要求这些模块都必须清楚该记录的结构，并按结构要求对此记录进行操作。在设计中应尽量避免这种耦合，它使在数据结构上的操作复杂化了。如果采取“信息隐蔽”的方法，把在数据结构上的操作全部集中。

调用模块和被调用模块之间传递数据结构而不是简单数据，同时也称作特征耦合。

在这个case中，m1传给m2的是一个对象。

// m1.js
me.m1input = this.value;
m2.update(me); // 传递引用
 
// m2.js
me.m2input = this.value;
m1.update(me);
1
2
3
4
5
6
7

查看完整代码和demo。

数据耦合

如果一个模块访问另一个模块时，彼此之间是通过数据参数(不是控制参数、公共数据结构或外部变量)来交换输入、输出信息的，则称这种耦合为数据耦合。由于限制了只通过参数表传递数据，按数据耦合开发的程序界面简单、安全可靠。因此，数据耦合是松散的耦合，模块之间的独立性比较强。在软件程序结构中至少必须有这类耦合。

调用模块和被调用模块之间只传递简单的数据项参数。相当于高级语言中的值传递。

在这个case中，m1传给m2的是一个简单数据结构。

// m1.js
me.m1input = this.value;
m2.update(me.m1input); // 传递值
 
// m2.js
me.m2input = this.value;
m1.update(me.m2input);
1
2
3
4
5
6
7

查看完整代码和demo。

非直接耦合

两个模块之间没有直接关系，它们之间的联系完全是通过主模块的控制和调用来实现的。耦合度最弱，模块独立性最强。

子模块无需知道对方的存在，子模块之间的联系，全部变成子模块和主模块之间的联系。

在这个case种，增加一个index.js作为主模块。

// index.js
var m1 = root.m1;
var m2 = root.m2;
 
m1.init(function (str) {
    m2.update(str);
});
 
m2.init(function (str) {
    m1.update(str);
});
 
// m1.js
me.m1input = this.value;
inputcb(me.m1input); // inputcb是回调函数
 
// m2.js
me.m2input = this.value;
inputcb(me.m2input);
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

查看完整代码和demo。

内聚

其实关于内聚也分为很多种，如下所示，如果你感兴趣可以自己研究研究，我们下次再来分享内聚的问题。

• 偶然内聚
• 逻辑内聚
• 时间内聚
• 通信内聚
• 顺序内聚
• 功能内聚

原文网址：http://yanhaijing.com/program/2016/09/01/about-coupling/

什么是解耦

解耦：假设生产者和消费者分别是两个类。如果让生产者直接调用消费者的某个方法，那么生产者对于消费者就会产生依赖（也就是耦合）。将来如果消费者的代码发生变化，可能会影响到生产者。而如果两者都依赖于某个缓冲区，两者之间不直接依赖，耦合也就相应降低了。生产者直接调用消费者的某个方法，还有另一个弊端。由于函数调用是同步的（或者叫阻塞的），在消费者的方法没有返回之前，生产者只好一直等在那边。万一消费者处理数据很慢，生产者就会白白糟蹋大好时光。缓冲区还有另一个好处。如果制造数据的速度时快时慢，缓冲区的好处就体现出来了。当数据制造快的时候，消费者来不及处理，未处理的数据可以暂时存在缓冲区中。等生产者的制造速度慢下来，消费者再慢慢处理掉。

因为太抽象，看过网上的说明之后，通过我的理解，我举了个例子：吃包子。

假如你非常喜欢吃包子（吃起来根本停不下来），今天，你妈妈（生产者）在蒸包子，厨房有张桌子（缓冲区），你妈妈将蒸熟的包子盛在盘子（消息）里，然后放到桌子上，你正在看巴西奥运会，看到蒸熟的包子放在厨房桌子上的盘子里，你就把盘子取走，一边吃包子一边看奥运。在这个过程中，你和你妈妈使用同一个桌子放置盘子和取走盘子，这里桌子就是一个共享对象。生产者添加食物，消费者取走食物。桌子的好处是，你妈妈不用直接把盘子给你，只是负责把包子装在盘子里放到桌子上，如果桌子满了，就不再放了，等待。而且生产者还有其他事情要做，消费者吃包子比较慢，生产者不能一直等消费者吃完包子把盘子放回去再去生产，因为吃包子的人有很多，如果这期间你好朋友来了，和你一起吃包子，生产者不用关注是哪个消费者去桌子上拿盘子，而消费者只去关注桌子上有没有放盘子，如果有，就端过来吃盘子中的包子，没有的话就等待。

原文：https://www.jianshu.com/p/5543b2eee223

---

公共耦合 c语言例子,小小的公共库，大大的耦合，你痛过吗？

已剪辑自: https://blog.csdn.net/weixin_39568781/article/details/117160353

什么是耦合?

耦合，是架构中，本来不相干的代码、模块、服务、系统因为某些原因联系在一起，各自独立性差，影响则相互影响，变动则相互变动的一种架构状态。

感官上，怎么发现系统中的耦合?

作为技术人，每每在心中骂上下游，骂兄弟部门，“这个东西跟我有什么关系?为什么需要我来配合做这个事情?”。明明不应该联动，却要被动受影响，就可能有潜在的耦合。

因为公共库，导致相互受影响，就是一个耦合的典型案例。

场景还原

一个看似“公共”的业务库(.so.jar .dll.php)，很多业务系统都依赖于这个公共库，这个库使得这些系统都耦合在了一起。

注：这里的公共库不是指像“字符串操作”这样的不变化的工具库，更多是指通用业务的公共库。

耦合如何导致相互影响?

业务1，业务2，业务3都依赖于某一个biz.jar，业务1因为某个需求需要升级biz.jar。上线前，业务1的QA进行了大量的测试，确保无误后，代码发布，发布完线上验证无误后，上线完成，闪人。

突然，bug群里有人反馈，业务2的系统挂了，业务3的系统也挂了，一下炸开了锅：

业务2的大boss首先发飙：“技术都干啥了，怎么系统挂了”

业务2的rd一脸无辜：“业务1上线了，所以我们挂了”

额，然而，这个理由，好像在大boss那解释不通…

业务2的大boss：“业务1上线?业务1上线前测试了么”

业务1的qa自信满满：“测试了呀，上线前上线后都验证了，没问题呀”

业务2的大boss对业务2的rd吼道“还想甩锅，拖出去祭天”

不知道大家工作中会不会遇到这样的场景，因为公共库的耦合，兄弟部门上线，影响的确是你，此时你心里可能就在骂娘了，这帮不靠谱的**队友。

特别的，如果公共库的使用方很广，这个耦合很严重，可能影响很大的范围。

如何解除公共库耦合?

方案一：代码拷贝一份

别嘲笑这个方案，谁敢说自己写代码的时候没这么干过?

我们都知道这不是一个好的方案，但不可否认，拷贝之后，代码各自演化，一个地方升级出错，只影响一方，拷贝方只要不动原有代码，至少是不会受影响的。

代码拷贝缺点很多，系统拆分时，万不得已不要使用这个方案。

方案二：垂直拆分，将公共库里业务个性化的代码拆到调用方去，不要放在公共库里

需要把业务个性的代码拆分到各个业务线自己的工程，自己的业务库里去，例如s1.jar / s2.jar / s3.jar，修改各自的代码，至少不会扩大影响范围。

大家为什么都把代码往一个公共库里塞?

很多时候，因为惰性，一点一点的惰性，日积月累，终成大坑。

这个垂直拆分是一个架构重构的过程，需要各业务方配合。

方案三：服务化，将公共库里通用业务代码拆到下层去

完成了第一步，业务个性化的代码提取到业务侧上游。

接下来是第二步，业务通用的代码，下沉抽取一层服务，服务对上游提供RPC接口：

每次修改底层接口，需要测试接口的兼容性，保证不影响旧调用方

如果是新的业务，则建议新增接口

最终，达到通过服务RPC调用的方式来解除耦合。

有朋友会问：

底层服务接口的测试

上游业务层对公共库的测试

都是测试，为何前者能控制影响范围呢?

底层接口，所有人调用，接口没问题则调用方都没问题

上游业务层对公共库测试，只能保证自己的业务没有问题，并不能保证其他业务方没有问题

个性业务代码上浮，共性业务代码服务化下沉，只是一个很小的优化点，但对于公共库解耦却是非常的有效。

---

用C语言实例描述程序中的内聚和耦合

已剪辑自: https://cloud.tencent.com/developer/article/1866225

编程时，我们讲究的是高内聚低耦合，在协同开发、代码移植、维护等环节都起到很重要的作用。

一、原理篇

而低耦合，是指模块之间尽可能的使其独立存在，模块之间不产生联系不可能，但模块与模块之间的接口应该尽量少而简单。这样，高内聚从整个程序中每一个模块的内部特征角度，低耦合从程序中各个模块之间的关联关系角度，对我们的设计提出了要求。

程序设计和软件工程发展过程中产生的很多技术、设计原则，都可以从内聚和耦合的角度进行解读。作为C语言程序设计的初学者，结合当前对于函数的理解可达到的程度，我们探讨一下如何做到高内聚低耦合。

针对低耦合。耦合程度最低的是非直接耦合，指两个函数之间的联系完全是通过共同的调用函数的控制和调用来实现的，耦合度最弱，函数的独立性最强。但一组函数之间没有数据传递显然不现实，次之追求数据耦合，调用函数和被调用函数之间只传递简单的数据参数，例如采用值传递方式的函数。

有些函数数在调用时，利用形式参数传地址的方式，在函数体内通过指针可以修改其指向的作用域以外的存储单元，这构成了更强的耦合，称为特征耦合，在这里，使函数之间产生联系的是地址这样的特征标识。另外，有两个函数可能会打开同一个文件进行操作，这也构成了特征耦合的一种形式。

更强的耦合是外部耦合，这里，一组模块都访问同一全局变量，而且不通过参数表传递该全局变量的信息，当发现程序执行结果异常时，很难定位到是在哪个函数中出了差错。不少初学者觉得参数传递麻烦，将要处理的数据尽可能地定义为全局变量，这样，函数之间的接口简单了，但形成的是耦合性很强的结构。

在C语言中，还可以通过静态局部变量，在同一个程序的两次调用之间共享数据，这也可以视为是一种外部耦合，只不过静态局部变量的作用域限于函数内部，其影响也只在函数内部，耦合程度比使全局变量也还是弱很多。由此，我们可以理解前述在使用全局变量、静态局部变量时提出的“用在合适的时候，不滥用”的原则。

针对高内聚。内聚程度最高的是功能内聚，模块内所有元素的各个组成部分全部都为完成同一个功能而存在，共同完成一个单一的功能，模块已不可再分。这样的函数功能非常清晰、明确，一般出现在程序结构图的较低被调用的层次上。

次之的是顺序内聚，一个函数中各个处理元素和同一个功能密切相关，通常前一个处理元素的输出是后一个处理元素的输入。对于这样的函数，如果不致于产生高耦合的话，可以分开两个函数实现。

有的函数，其中的不同处理功能仅仅是由于都访问某一个公用数据而发生关联，这称为通信内聚和信息内聚，内聚程度进一步下降。内聚程度再低的情况就不再一一列举，最差的偶然内聚中，一个函数内的各处理元素之间没有任何联系，只是偶然地被凑到一起。

可以想像这样的模块东一榔头西一锤子，类似一个毫无凝聚力的团伙，对应的是低质量。总之，在解决问题划分函数时，要遵循“一个函数，一个功能”的原则，尽可能使模块达到功能内聚。

要做到高内聚低耦合，重点是要在写代码之前花些时间做好设计。在下面的例子中，将讨论结合具体的问题，如何将以上的因素考虑进去。

二、示例篇

本例受裘宗燕老师《从问题到程序——程序设计与C语言引论启发》。

任务 输出200以内的完全平方数（一个数如果是另一个整数的完全平方，那么我们就称这个数为完全平方数，也叫做平方数），要求每隔5个数据要输出一个换行。

解决方案及点评 对于这个简单任务，我们在一个main函数中完成了任务。程序如方案1：

//方案1：内聚性较高的单模块实现方案
#include <stdio.h>
int main()
{
    int m, num=0;
    for (m = 1; m * m <= 200; m++)
    {
        printf("%d ", m * m);
        num++;
        if (num%5==0)
            printf("\n");
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

由于任务本身简单，将之在一个main函数中实现后，这个函数的内聚程度接近功能内聚，已经相当高了，就任务本身，不需再进行分解。为使读者能深入理解模块质量方面的技术，我们将试图将内聚程序再提高一些，然后考察耦合程度不同的各种解决方案。

要提高上面解决方案中函数（仅main一个函数）的内聚程度，我们考察程度的功能“找出完全平方数并输出”——“找出完全平方数”和“输出”这本身就是两个功能，再细分输出时还有“要求5个数据在一行”的要求，这些功能的实现细节都在一个函数当中，可见是有余地再提高内聚程度的。

在实现的应用中，几乎所有的处理都可以分解为“输入-计算-输出”的模式，优秀的解决方案往往至少要将这三个模块都独立出来，对于“计算”模块而言，其内部不再包括输入输出，专门接受输入的数据，计算完成后返回结果即可。当然，对于复杂的问题，在各个环节上可能还需要再做分解。

下面，我们探讨将“找出完全平方数输出”和“每5个数据后换行”分开实现的方案。这样的分解有助于提高内聚性，与此同时，分解后的两个模块间的耦合程度，成为我们要关注的焦点。

现在将“找出完全平方数并输出”的功能仍放在main函数中（独立成为单独的函数也可以，但不必要了），而“每5个数据后换行”的功能，设计一个名称为format的函数，它每调用一次就输出一个空格作为两个完全平方数间的分隔，而每调用到第5次时，输出的是一个换行。

这两个模块之间，需要有一个“现在是第几次调用”的信息需要传递，不可能用耦合程度最松散的非直接耦合.我们考虑数据耦合，用简单形式参数传值，得到方案2。

//方案2：一个耦合度低，但不能完成功能要求的解决方案
#include <stdio.h>
void format(int);
int main()
{
    int m, num=0;
    for (m = 1; m * m <= 200; m++)
    {
        printf("%d", m * m);
        format(num);
    }
    return 0;
}
void format(int n)
{
    n++;
    if (n%5==0)
        printf("\n");
    else
        printf(" ");
    return;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个程序结构中，format与main函数的耦合程度为数据耦合。在main中定义了局部变量num，在一次都未输出时，置初值为0是合理的。在调用format时，将num传递来的表示第几次输出（第几个完全平方数）的形式参数n，n自增1，然后再控制输出空格或换行。

然而分析和运行程序发现，“每隔5个数据输出一个换行”的功能并未实现。因为形式参数n在函数format内的改变对应的实在参数num占不同的内存空间，n++修改的结果，对num无任何的影响，导致了在下一次调用时，丢失了“输出的是第几个”的重要信息。

一个补救的方法，是由format将变化后的n值作为返回值，再传回给main函数，得到如下方案3的程序：

//方案3：利用了返回值使耦合度增大，但功能得以实现的方案
#include <stdio.h>
int format(int);
int main()
{
    int m, num=0;
    for (m = 1; m * m <= 200; m++)
    {
        printf("%d", m * m);
        num = format(num);
    }
    return 0;
}
int format(int n)
{
    n++;
    if (n%5==0)
        printf("\n");
    else
        printf(" ");
    return n;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

维持原函数返回值为void，而将参数改为传地址，得到下面的方案4。这个方案的耦合度更高一些，但功能还是能够实现的。

//方案4：传地址实现功能的方案，耦合度更大
#include <stdio.h>
void format(int*);
int main()
{
    int m, num=0;
    for (m = 1; m * m <= 200; m++)
    {
        printf("%d", m * m);
        format(&num);
    }
    return 0;
}
void format(int *p)
{
    (*p)++;
    if ((*p)%5==0)
        printf("\n");
    else
        printf(" ");
    return;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

一定有人想到了用全局变量的解决方案。这样，可以将num定义为全局变量，num的生存周期不再依赖于函数调用，其值也能在函数的调用之间保持不变（只要其间没有另外给它赋值），从而可以完成传递信息的任务。这时，format因为无需参数传递，可以设计为无参函数，得到如下方案5的程序：

//方案5：耦合度最高的全局变量方案
#include <stdio.h>
void format();
int num=0;
int main()
{
    int m ;
    for (m = 1; m * m <= 200; m++)
    {
        printf("%d", m * m);
        format();
    }
    return 0;
}
void format()
{
    num++;
    if (num%5==0)
        printf("\n");
    else
        printf(" ");
    return;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

这是解决这个问题的耦合程度最高的一个方案。将num定义为外部变量，意味着如果还有其他函数，num是可以被任何函数修改的，当发 format 计数错误时，寻找错误困难，而修改后又可能会带来其他地方的错误。在这么一个短小的程序中，这种方案可能尚可接受，当程度的规模稍变大，可能带来的问题必须高度重视。因此，在实际应用中，强调全局变量要慎用（不是不用）。

考虑到num是在format中应用的私用数据——只有format才关心这到底是第几个数据，main本来都不用关心的。这样，可以考虑将num定义为format中的局部静态变量，得到方案6的程序：

//方案6：用静态局部变量，耦合度偏高但封装性最好的方案
#include <stdio.h>
void format();
int main()
{
    int m ;
    for (m = 1; m * m <= 200; m++)
    {
        printf("%d", m * m);
        format();
    }
    return 0;
}
void format()
{
    static int num=0;
    num++;
    if (num%5==0)
        printf("\n");
    else
        printf(" ");
    return;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在这里，静态局部变量num的作用域是局部的，定义在函数体里，封装性在所有方案里是最好的，从而能保证信息的隐蔽性，避免其他函数无意的越权访问；不过，num的生存期是全局的，可以跨越函数的不同次调用，在两次调用间传递信息，耦合程度（自己和自己的耦合）要高一些，但使main函数和format函数的耦合达到了最理想的程度，既保证了功能的正确，又保证了局部数据的安全性，表现出静态局部变量的优势。综上所述，在解决一个问题时，存在着诸多的方案。方案1可以接受，但希望提高内聚性而做出改进；方案2用简单的参数传值方式实现耦合程度低，但很可惜不能完成功能；在其他方案中，对于这个问题，选择的优先顺序是：

❝方案6、方案3 > 方案4 > 方案5 ❞

建议读者回顾前面的内容，想一想这样排序的理由。在上述探讨各个方案的过程中，我们应该体会到在程序设计能力提高的过程中，不断地学习新的技术，懂得新的评判标准，这也就是一个不断拓宽眼蜀的过程。在稍后的练习中，不妨多想一些方案，也能够从专业的角度评判方案的优劣，最终做到的，就是出手就是最佳方案的专业水平。

来源：https://helijian.blog.csdn.net/article/details/79401703

---

用C语言编写低耦合程序

已剪辑自: https://zhuanlan.zhihu.com/p/270880191

耦合的定义

耦合，是对模块间关联程度的度量。 模块间的耦合度是指模块之间的依赖关系，其耦合性越强，同时表明其独立性越差。

低耦合的优点

降低模块间的耦合度能减少模块间的影响，防止对某一模块修改所引起的“牵一发动全身”的水波效应，保证系统设计顺利进行。

实现例子

实现两个功能：

1、统计字符串的单词总数。

2、统计字符串中长度大于n的个数。

在这两个功能中，都需要将字符串中的每个单词分离单独处理。

普通的实现方式

typedef enum _parse_words_mode_t {
  MODE_SUM = 0,  /* 模式:统计单词总数 */
  MODE_SUM_GT,   /* 模式:统计长度大于n单词数 */
} parse_words_mode_t;

int count_words(const char* str, parse_words_mode_t mode, int len)
{
  int ret = 0;
  if(NULL == str || len < 0){
    return FALSE;
  }
  bool ret = TRUE;
  for (const char* iter = str; '\0' != *iter; iter++) {
    /** 获取单词word和单词长度word_len（省略） **/
    if(MODE_SUM == mode){
      ret++;
    }else if(MODE_SUM_GT == mode){
       if(word_len > len){
         ret++;
       }
    }
  }
  return ret;
}

int main()
{
  char str[64] = "Read Text, demo.kun abcdefg abcdefg";

  int32_t sum_word = count_words(str, MODE_SUM, 0);
  if (sum_word >= 0) {
    printf("\nword num:%d\n", sum_word);
  }
  int32_t gt6_word = count_words(str, MODE_SUM_GT, 6);
  if (gt6_word >= 0) {
    printf("\ngreat 6 letter : word num:%d\n", gt6_word);
  }
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

这个方法看上去好像没什么问题，但如果功能增加了十多个，那么count_words函数的选择结构就会越来越庞大，修改就会变得麻烦。

低耦合的实现方式

使用函数指针调用功能函数来代替使用选择结构（if else; switch case）调用函数。

函数指针类型参数使用void*类型的ctx变量作为功能函数的上下文，即功能函数的返回值或一些参数。

函数指针类型返回值用于判断函数执行是否成功。

typedef int bool;
#define TRUE 1
#define FALSE 0

/* 定义函数指针类型名 */
typedef bool (*on_word_t)(void* ctx, const char* word, unsigned int size);

/**
 * @method parse_words
 * 解析字符串中的单词
 * @param {const char*} str 需要解析单词的字符串。
 * @param {on_word_t} word_func 单词处理函数指针。
 * @param {void*} ctx 单词处理函数指针的上下文。
 *
 * @return {bool} 解析成功则返回TRUE。
 */
bool parse_words(const char* str, on_word_t word_func, void* ctx) {
  if(NULL == str || NULL == word_func){
    return FALSE;
  }
  bool ret = TRUE;
  for (const char* iter = str; '\0' != *iter; iter++) {
    /** 获取单词word和单词长度len（省略） **/
    ret = word_func(ctx, word, len + 1); /* 通过函数指针调用功能函数 */
  }
  return ret;
}

/* 统计单词总数 */
static bool words_sum(void* ctx, const char* word, unsigned int size){
  if(NULL == ctx){
    return FALSE;
  }
  int* p_count = ctx;
  (*p_count)++;  /* 单词数+1 */
  return TRUE;
}

/**
 * @method count_word_sum
 * 计算单词总数。
 * @param {const char*} str 需要计算单词总数的字符串。
 *
 * @return {int} 单词总数（若计算的字符串为空指针，返回值为-1）。
 */
int count_words_sum(const char* str) {
  int ret = 0;
  return (TRUE == parse_words(str, words_sum, &ret)) ? ret : -1;
}
/* 统计长度大于n的单词数 */
/* count_word_sum_gt()函数内部使用的相关参数 */
typedef struct _ctx_word_sum_gt {
  int count;  /* 单词数 */
  const unsigned int word_len;  /* 单词长度 */
} ctx_word_sum_gt;

static bool words_sum_gt(void* ctx, const char* word, unsigned int size) {
  if(NULL == ctx){
    return FALSE;
  }
  ctx_word_sum_gt* sum_gt_ctx = ctx;
  if ((size - 1) > sum_gt_ctx->word_len) {  /* 长度是否大于word_len */
    sum_gt_ctx->count++;  /* 单词数+1 */
  }
  return TRUE;
}

/**
 * @method count_word_sum_gt
 * 计算单词长度大于word_len的数量。（word_len为0时为单词总数）
 * @param {const char*} str 需要计算单词数量的字符串。
 * @param {int} word_len 单词长度。
 *
 * @return {int} 单词数量（若计算的字符串为空指针或单词长度小于0，返回值为-1）。
 */
int count_words_sum_gt(const char* str, int word_len) {
  if(word_len < 0){
    return -1;
  }
  ctx_word_sum_gt ret = {
    .count = 0,
    .word_len = word_len,
  };
  return (TRUE == parse_words(str, words_sum_gt, &ret)) ? ret.count : -1;
}
int main()
{
  char str[64] = "Read Text, demo.kun abcdefg abcdefg";

  int32_t sum_word = count_word_sum(str);
  if (sum_word >= 0) {
    printf("\nword num:%d\n", sum_word);
  }
  int32_t gt6_word = count_word_sum_gt(str, 6);
  if (gt6_word >= 0) {
    printf("\ngreat 6 letter : word num:%d\n", gt6_word);
  }
  return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

使用低耦合的实现方式将不变的代码和易变的代码隔离，在添加新功能时，无需再改动原有的函数，更加安全和高效。

---

C语言使用注册回调方式实现模块间交互（解耦合）

已剪辑自: https://cchang.blog.csdn.net/article/details/122279130?spm=1001.2014.3001.5502

目录

一、实现说明

二、代码

1、模块A代码

1)A.h

2)A.C

2、模块B代码

1)B.h

2)B.C

3、模块C代码

1)C.h

2)C.C

4、模块D代码

1)D.h

2)D.C

5、main函数代码

三、输出

一、实现说明

在C语言中，若需实现A模块满足某个条件，调用B模块、C模块、D模块…等模块中某个函数，一般采用如下写法（伪代码）：

void AFunc()
{
	if (condition1) {
		BFunc();
	}
	if (condition2) {
		CFunc();
	}
	if (condition3) {
		DFunc();
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

可看出模块间偶尔较多，若B、C、D模块需要做什么修改，均需要嵌入的修改A模块，不满足C语言“对扩展开放，对修改关闭”的原理，因此采用了注册回调的方式，A模块提供注册回调的接口，B、C、D各模块在本模块内部注册回调，并根据需要进行对应的实现，在A模块满足某个条件时，依次调用各个回调函数即可。

如下所示，A模块提供回调注册接口，B、C、D模块通过注册接口注册自身的回调函数，当模块A满足某个条件，触发了FuncA时，在FuncA中依次调用其他模块注册的回调函数。

二、代码

1、模块A代码

1)A.h

#ifndef A_H
#define A_H
#include <stdio.h>
#include <stdbool.h>
 
#define MAX_CALLBACK_LEN 15
typedef void (*Func)(int);
 
bool RegisterCallback(Func callback);
void FuncA(int arg);
 
#endif
1
2
3
4
5
6
7
8
9
10
11
12

2)A.C

#include <stdio.h>
#include <stdbool.h>
#include "A.h"
 
Func callbackMap[MAX_CALLBACK_LEN] = { NULL };
static int g_maxRegisterCallback = 0;
 
bool RegisterCallback(Func callback)
{
	if (callback == NULL) {
		return false;
	}
 
	if (g_maxRegisterCallback >= MAX_CALLBACK_LEN) {
		return false;
	}
 
	callbackMap[g_maxRegisterCallback] = callback;
	g_maxRegisterCallback += 1;
	return true;
}
 
void FuncA(int arg)
{
	g_maxRegisterCallback = (g_maxRegisterCallback > MAX_CALLBACK_LEN) ? MAX_CALLBACK_LEN : g_maxRegisterCallback;
	printf("[FuncA]MaxRegisterCallback= %d, arg = %d\r\n", g_maxRegisterCallback, arg);
	for (int i = 0; i < g_maxRegisterCallback; i++) {
		callbackMap[i](arg);
	}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

2、模块B代码

1)B.h

#ifndef B_H
#define B_H
void RegisterFuncB();
#endif
1
2
3
4

2)B.C

#include <stdio.h>
#include <stdbool.h>
#include "A.h"
#include "B.h"
 
void FuncB(int arg)
{
	printf("[FuncB]arg = %d\r\n", arg);
}
 
void RegisterFuncB()
{
	bool ret = RegisterCallback(FuncB);
	printf("[RegisterFuncB]Register Ret = %d\r\n", ret);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

3、模块C代码

1)C.h

#ifndef C_H
#define C_H
void RegisterFuncC();
#endif
1
2
3
4

2)C.C

#include <stdio.h>
#include <stdbool.h>
#include "A.h"
#include "C.h"
 
void FuncC(int arg)
{
	printf("[FuncC]arg = %d\r\n", arg);
}
 
void RegisterFuncC()
{
	bool ret = RegisterCallback(FuncC);
	printf("[RegisterFuncC]Register Ret = %d\r\n", ret);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

4、模块D代码

1)D.h

#ifndef D_H
#define D_H
void RegisterFuncD();
1
2
3

2)D.C

#include <stdio.h>
#include <stdbool.h>
#include "A.h"
#include "D.h"
 
void FuncD(int arg)
{
	printf("[FuncD]arg = %d\r\n", arg);
}
 
void RegisterFuncD()
{
	bool ret = RegisterCallback(FuncD);
	printf("[RegisterFuncD]Register Ret = %d\r\n", ret);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

5、main函数代码

#include <stdio.h>
#include "A.h"
#include "B.h"
#include "D.h"
#include "C.h"
 
int main()
{
	RegisterFuncB();
	RegisterFuncC();
	RegisterFuncD();
	FuncA(10);
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

三、输出