开源软件中结构复杂度的度量方法
白盒测试分析代码质量和复杂度的关键工具
白盒测试分析代码质量和复杂度的关键工具当今软件开发行业日新月异，各种类型的软件层出不穷。
为了确保软件产品的质量和稳定性，对代码的测试变得尤为重要。
白盒测试作为一种重要的测试方式，通过检查和分析代码内部结构与逻辑，可以有效地评估代码的质量和复杂度。
在白盒测试中，有一些关键工具在分析代码质量和复杂度方面发挥着重要的作用。
一、静态代码分析工具静态代码分析工具是白盒测试中常用的工具之一。
它通过对源代码进行扫描和分析，可以自动检测出潜在的编码错误、代码风格不符合规范等问题。
静态代码分析工具可以对代码进行全面的检查，帮助开发人员及时发现并修复问题，提高代码的可读性和可维护性。
1. SonarQubeSonarQube是一种开源的静态代码分析工具，被广泛应用于软件开发领域。
它支持多种编程语言，包括Java、C++、C#等，并提供了一系列插件和规则集，可以检查代码的质量、复杂度以及安全性等方面的问题。
SonarQube可以为开发团队提供实时的代码质量报告，帮助开发人员及时发现和解决问题。
2. CheckstyleCheckstyle是一个针对Java代码的静态代码分析工具。
它可以检查代码是否符合一定的编码规范，如命名规范、代码格式等。
Checkstyle 提供了丰富的配置选项，可以根据开发团队的需求进行灵活的配置。
通过使用Checkstyle，开发人员可以统一代码的风格，提高代码的可读性和可维护性。
二、代码复杂度分析工具除了代码质量的分析，代码复杂度的评估也是白盒测试的重要方面。
代码复杂度分析工具通过对代码的结构和逻辑进行分析，可以衡量代码的复杂程度，并给出相应的指标。
代码复杂度分析工具可以帮助开发人员找出过于复杂的代码，优化代码结构，提高代码的可理解性和可维护性。
1. PMDPMD是一种开源工具，用于检测代码中的问题和潜在的错误。
它支持多种编程语言，如Java、C/C++、Ruby等。
PMD提供了多个内置规则集，可以检测代码的复杂度、重复代码、未使用的变量等问题。
软件测试中的复杂度分析
软件测试中的复杂度分析在软件测试过程中，复杂度分析是一个重要的步骤。
通过分析软件项目的复杂度，我们可以评估测试的难度，并制定出合理的测试策略和方法。
本文将介绍软件测试中的复杂度分析方法和其在测试过程中的应用。
一、复杂度分析的意义复杂度分析是指对软件系统或者系统组件的结构、功能、接口、数据等进行分析，以评估其复杂度。
它可以帮助测试人员全面了解被测软件的复杂程度，为测试活动提供有效的指导和决策支持。
通过复杂度分析，测试人员可以确定测试的重点和难点，为测试资源的合理配置提供依据，提高测试效率和测试质量。
二、复杂度分析方法1. 静态复杂度分析静态复杂度分析是指通过对被测软件的源代码、设计文档等进行分析，计算出软件系统的复杂度。
常用的静态复杂度分析方法包括：（1）代码行数统计：通过统计软件系统的代码行数来评估软件的复杂程度。
代码行数越多，软件的复杂度相对较高。
（2）圈复杂度分析：圈复杂度是一种对软件模块的复杂度进行量化的方法。
它通过计算一个模块中的判定结构的数量来评估模块的复杂度。
圈复杂度越高，模块的复杂度越高。
2. 动态复杂度分析动态复杂度分析是指通过执行软件系统的测试用例来评估软件的复杂程度。
常用的动态复杂度分析方法包括：（1）路径覆盖分析：路径覆盖分析是指对软件系统的各个执行路径进行覆盖度分析。
通过分析每个路径的覆盖情况，可以评估软件的复杂程度和测试用例的覆盖能力。
（2）数据流分析：数据流分析是指对软件系统中的数据流进行分析。
通过跟踪数据的流向和变换，可以评估软件系统的复杂度和数据依赖关系。
三、复杂度分析的应用复杂度分析在软件测试过程中具有重要的应用价值。
1. 确定测试的重点和难点通过复杂度分析，可以确定被测软件系统中的重点模块和难点模块。
在测试资源有限的情况下，测试人员可以将更多的测试时间和资源用于这些模块上，提高测试的覆盖率和效果。
2. 制定合理的测试策略和方法根据复杂度分析的结果，测试人员可以制定出合理的测试策略和方法。
基于复杂度对开源软件Linux和FreeBSD内核的分析
ｓ ｆ ａ ｅ Ｓｅ ｏｕ ｉｎ ｃ ｎ ｈ ｌ Ｓ ｔ ｍｐ ｒ ａｌ ｓｉ ｔ ｈ ｔ ｂｌ ｙ ｏ ｏ ｔ ｒ ｒ ｈｔ ｃｕ ｅ ａ ｄ ｔ ｏｅ ａ ｔｓ ｆ ｒ ’ ｖ ｌ ｔ ｎ ｔ ｎ ｎ ｏ ｔ ｒ ’ ｖ ｌｔ ａ ｅ ｐ Ｕ ｏ ｅ ｉｉ ｌ ｅ ｔ ｗ ｏ ｃ ｙ ｍａｅ ｔ ｅ ｓａ ｉ ｔ ｆｓ ｆ ｉ ｗａｅ ａ ｃ ｉ ｔｒ ， ｎ ｏ ｆｒ ｃ ｓ ｏｔ ｅ Ｓ ｅ ｏ ｕｉ ｒ ｄ ａ ｄ ｅ ｗａ ｏ ｅ ｅ ｏｕ ｉｎ ｏ ｔｏ ｓ ｗ ｔ ｒｆ ｒ ｌ ｃ ｕ ａ ｙ Ｉ ｈ ｓ ａｔ ｌ ｅ ｅ ｔｔ ｅ ｋ ｒ ｅ ｓ ｏ ｕ ｅ ｆＬ ｎ ｘ ａ ｄ Ｆ ｅ Ｂ Ｄ ｖ ｒｉｎ ｏ ｃ ｌ ｃ ｎ ｖ ｌ ｔ ｕ ｃ ｍｅ ｉ ｐ ｅ ａ ｅ ａ ｃ ｒｃ ． ｎ ｔｉ ｒｉ ｅ ｗｅ ｓ ｌ ｃ ｈ ｅ ｎ ｌ ｆ ａ ｎ ｍｂ ｒ ｏ ｉｕ ｎ ｒ ｅ Ｓ ｅ ｓｏ ｓ ｔ ｏｌ ｔａ ｄ ｏ ｈ ｏ ｂ ｃ ｅ ｐ ｏ ｅ ｓｔ ｅｒ ｄ ｔ ． ｙ ｕ ｉ ｇ ｌｗ— ｖ ｌ ｔｉ ｅ ｒ ｅａ ｄ ｕ ｉ ｓｎ ｎ ｌｓｓｔ ｏｓＳ ＯＣ ＮＴ ａ ｄ ＣＣ Ｃ ｔ ｎ ｌｓ ｅ ｅ ｔ ｃｅ ｅ ｌ ａａ ｗｅ ｒ ｃ ｓ ｈ ｉ ａａ Ｂ ｓ ｎ ｏ ｌ ｅ ｒ ｄ ｇ ｅ ｎ ｔ ｉｉｇ ａ ａｙ ｉ ｏ ｌ Ｌ ＯＵ ｎ Ｃ ｏ ａ ａｙ ｅ ｔ ｘ ｒ ｔ ｄ ｋ ｍｅ ｔ ， ｅ ｍｅ ｃ ｌ ｈ ａ ｄ ｄ ｒ ｅ ｔ ｅ ｃ ｎ ｌｓｏ ｆ ｈ ｖ ｌ ｔ ｎ ｏ ｐ ｎ ｓ ｕ ｃ ｒｅ ｓ ｆ ｒ ａ ｄ ｐ ｏ ｏ ｅ ｔ ｅａ ｐ ｏ ｃ ｏ ｓ ｓ ｒ ｅ ｉｇ ｔ ｅｅ ｏｕ ｉｎ ｔ ｎ ｅ ｃ ｎ ｏ ｅ ｉ ｈ ｏ ｃｕ ｉｎ ｏ ｅ ｅ ｏ ｕ ｉ ｆ ｅ ｏ ｒ ｅｆｅ ｏｔ ｅ， ｎ ｒｐ ｓ ｐ ｒ ａ ｈ ｆ ｒ ａ ｔ ｕ ｖ ｙｎ ｖ ｌ ｔ ｄ ｎ ｙａ ｄ ｃ ｎ－ ｖ ｔ ｏ ｏ ｗａ ｈ ｆ ｈ ｏ ｅ ｐｅ ｉ ｆ ａ ｇ ｃ ｌ ｐ ｎ ｓ ｕ ｃ ｏｔ ｒ ｅ ｌｘｔ ｏ ｒｅ ｓ ａｅ ｏ ｅ ｏ ｒ ｅ ｓ ｆ ｙ ｌ ｗａ ． Ｋｅ ｗｏ ｄ ｙ ｒｓ Ｌ ｎ ｘ Ｆ ｅ ＢＳ Ｏｐ ｎ ｓ ｕ ｃ ｏｔ ｒ Ｓ ｆ ａ ｅ ｅ ｏｕ ｉｎ Ｓ ｆ ａ ｅ Ｃ ｍｐ ｅ ｉ ｉｕ ｒｅ Ｄ ｅ ｏ ｒｅｓｆ ｗａｅ ｏｔ ｒ ｖ ｌｔ ｏｔ ｒ ｏ ｌｘｔ ｗ ｏ ｗ ｙ
代码复杂度衡量方法
代码复杂度衡量方法English:Code complexity is typically measured using methods such as cyclomatic complexity, which evaluates the number of independent paths through a program's source code. Other methods include Halstead complexity measures, which assess the volume and difficulty of code, and maintainability index, which combines various metrics to quantify how maintainable the code is. Cyclomatic complexity calculates the number of decision points in a program, highlighting sections of code that could be difficult to understand or maintain. Halstead complexity measures compute the total number of operators and operands, as well as the number of distinct operators and operands, to provide a quantitative measure of code complexity. The maintainability index uses various factors such as cyclomatic complexity, lines of code, and Halstead volume to determine how maintainable the code is, with lower values indicating higher maintainability. These methods help developers understand the complexity of their code and identify areas for improvement to enhance readability, maintainability, and overall quality.中文翻译:代码复杂度通常使用诸如圈复杂度这样的方法来衡量，圈复杂度评估程序源代码中独立路径的数量。
软件工程中的软件质量度量方法(七)
软件工程中的软件质量度量方法一、引言在软件开发过程中，软件的质量是衡量其成功与否的重要标准之一。
软件质量度量方法的选择和应用直接影响着开发团队的决策和项目的最终结果。
本文将介绍几种常见的软件质量度量方法，并探讨它们的优缺点及适用场景。
二、静态度量方法1. 代码行数代码行数是一种最为简单直接的度量方法，通常用于评估软件的规模和复杂度。
较大的代码行数可以表明软件的规模较大，但并不一定代表其质量较高。
因此，单纯依靠代码行数作为质量度量指标是不全面的。
2. 代码复杂度代码复杂度是指软件代码的结构和逻辑的复杂程度。
复杂的代码通常会导致维护困难和错误潜在风险的增加。
通过使用诸如McCabe圈复杂度等度量方法，可以评估代码的复杂度，并据此进行代码重构和性能优化。
3. 代码内聚性代码内聚性是指软件内部模块的联系和紧密程度。
高内聚的代码意味着模块之间的依赖性低，易于维护和重用。
反之，低内聚的代码可能导致模块之间的耦合性较高，增加了代码的复杂性和错误发生的风险。
三、动态度量方法1. 单元测试覆盖率单元测试是软件开发过程中的重要环节，它通过对软件单元进行测试并收集结果，以评估软件的行为是否符合预期。
单元测试覆盖率是评估测试覆盖范围的指标，通常以百分比的形式表示。
较高的覆盖率意味着测试用例覆盖了更多的代码路径，减少了未被测试到的潜在错误。
2.缺陷密度缺陷密度是评估软件质量的重要指标，表示在每个代码行或每个功能点上的缺陷数量。
缺陷密度越低，表明软件质量越高。
通过缺陷密度的度量，可以及时掌握软件的质量状态，并定位和修复潜在的问题。
3. 性能测试性能测试旨在评估软件在不同负载条件下的性能表现。
通过模拟和测量软件的响应时间、吞吐量等指标，可以判断软件在实际使用环境下的可用性和稳定性。
性能测试可以帮助开发团队发现和解决性能瓶颈，并提升软件的用户体验。
四、可视化度量方法1. 数据可视化数据可视化是通过图表、图形等形式直观地展示软件度量指标和统计数据的方法。
如何称量代码复杂度（C++C#）-管理资料
如何称量代码复杂度（C++C#）-管理资料微博上的蛙蛙王子提出三个设想，发送给微博上一些知名程序员，惊悚的是，这三个问题我以前也考虑过还动手做过，。
这是巧合呢？还是巧合涅？蛙蛙王子的问题是：是否有个工具可以检测出函数的长度？检测出函数中嵌套的层次？是否可以检测出重复代码？基于我在罗克韦尔时写的一个Lua脚本经验来看，第一第二个问题非常容易。
第三个问题稍有麻烦，有工具或者开源项目能做到，但是效果一般。
回到标题上的问题，称量代码复杂度，可以通过实现某个工具检测长度或者嵌套层次来完成，还有另外更简单的办法。
通常情况下，复杂代码所在文件大小也会比其他文件大出不少，所以不用编写什么工具，只要逐个察看项目中个头比较大的文件，就可以找到代码味道不好的地方了。
另外一个办法是通过版本控制工具，什么样的文件需要重构？基本上修改check in 次数多的文件，你要考虑重构了，即使代码味道不错，也肯定是责任过重，这个办法也很简单，把history导出统计一下就可以了。
如果通过判断函数长度和嵌套层次，建议大家可以这样实现，我考虑过C++的实现，算是比较完整，不需要什么编译原理知识。
函数长度和嵌套层次可以这样判断。
前提1，我们可以确定C++中的{}成对出现；前提2，class可以通过关键字定位，而struct可以假定其中没有函数体，不需要判断；前提3，函数中的{}也一定是成对出现。
至于其他的复杂问题，我觉得没必要考虑太多，除非你想做一个商用级别的软件，否则一个Python脚本就能搞定。
基于这些前提我们可以这样实现，先清理注释部分，C++注释分成// /*，另外对于/*要考虑单行和多行，基本上就是按行处理就行了，管理资料《如何称量代码复杂度（C++/C#）》(https://www.)。
之所以这样，是为了防止注释部分包含{}或者特定关键字。
如果能找到class，判断类名，然后查找{。
对于{}匹配，可以定义一个树形结构，函数或者类作为根，发现一个{，加入一层嵌套，发现一个}，减去一层嵌套。
开源软件中结构复杂度的度量方法
ｐｐ能提供软件在 方法层 和抽 象层设计依赖 关系 ，这种关系 ｈ） 是运行时的依赖关系，度量框架界面如图 １ 所示。
国 内外 研究工作者 【 已经将 随机 图论 应用在开源 软件 ｊ 的管理 。经典的随机 图特性只能解释某些结构特性 ，但很难 直接应用在软件 包管理上。例如 ，度分析能说 明软件包在互
第 ３ 卷 第 ｌ 期 ６ Ｏ
Ｉ ３６ ｉ ｏＬ
・
计
算
机
工
程
２１ ０ ０年 ５月
Ｍ ａ ０１ ｙ２ ０
Ｎｏ１ ．ｏ
Ｃｏｍｐｕｔ ｒＥｎ ｎｅ ｒｎｇ ｅ ｇｉ ｅ ｉ
软 件 技术 与数据 库 ・
文章编号： ０ ３２（ １） ＿ ０１ 文献 码：Ａ ｌｏ＿ ４８ ０ｏ ＿ ６— ３ ２ ｌ ０ 标识
将软件包之 问的依赖关系抽象成有向边 ， 建立 随机 图， 并引入结构熵 的概念 。 结合随机图的特性和结构熵 度量开源软件 的耦合度 和内聚度 。 利用该方法进行实例分析 ，结果表 明，随着开源软件按版本发展 ，软件耦合度 和内聚度 不断增长 。
关健词 ：开源软件 ；随机 图；结构熵 ；耦合 ；内聚
ｎ ｗ ｅｈ ｆｍｅ ｓ ｉｇｓｒ ｃｕｒｌｃ ｍｐｌｘｔ ｆｏ ｅ ｏ ｒｅｓ ｆｗａｅ Ｉ ｕ ｅ ｈ ｔ ｏ ｙｔ ａ ｔ ｏｉｖ ｓｉａｅｔａ ｓｔｅｒｌａ ｅｏ ｈ ｐ ｎ ｅ ｍ ｔｏｄｏ ａ ｕ ｎ ｔｕ ｔ ａ ｏ ｒ ｅ ｉ ｏ ｐ ｎ ｓ ｕ ｃ ｏ ｙ ｔ ｒ ．ｔ ｓ ｓｔｅｍｅ ｄｂ ｆｃ ｅ ｔ ｔ ｈ ｔａ ｅｅ ｓ ｆｔｅｏ ｅ ｈ ｈｅ ｔ ｎ ｇ ｈ
Ｍ ｅ ｓ ｅＭ ｅ ｈｏ ｆＳ ｒ ｔ ａ ａ ｕｒ ｔ ｄ ０ ｔ ｕｃ ｕｒ ｌＣｏｍ ｐ ｅ ｉ ｉ ｌ ｘ ｎ Ｏｐｅ ｕｒ ｅＳｏ ｔ ｒ ｎ Ｓｏ ｃ ｆｗａ ｅ
面向对象软件工程中的软件复杂度度量研究
面向对象软件工程中的软件复杂度度量研究引言：面向对象编程是一种广泛应用的软件开发方法，其在软件开发领域中占有重要地位。
随着软件的不断复杂化，软件的质量和性能也变得更加重要。
无论是开发大型商业软件，还是开发小型应用软件，都需要对软件的复杂度进行评估和度量。
软件复杂度是指软件系统的结构、规模、难度和精度等，是评估软件质量和可维护性的重要指标，也是进行软件开发过程中最重要的质量度量之一。
软件复杂度的度量方法：在软件开发领域中，有多种度量软件复杂度的方法和指标。
其中，最常用的度量方式是基于面向对象的软件复杂度度量。
面向对象软件的复杂度是由类、继承、组合、消息传递和多态性等多方面因素影响的。
因此，对于面向对象软件，必须考虑多个因素。
面向对象软件复杂度的度量指标主要包括：1.类的复杂度。
类的复杂度是指一个类中各种元素的组合和层次结构所引起的复杂度，《面向对象软件度量》(OO-Metric)强调了基于类和方法的度量方法。
2.继承的复杂度。
继承的复杂度是指基于继承关系构成的代码结构的复杂度。
继承多层次结构使得代码的复杂度增加。
3.组合的复杂度。
组合的复杂度是指类和对象的相互关联以及它们的拓扑关系，包括引用、嵌套和聚合关系，它们会形成不同的组件、子系统或系统之间的复杂结构。
4.消息传递压力。
消息传递压力是指代码中消息的数量和复杂度，包括同步、异步和回调等方式，它们会导致更高的系统耦合性和降低的可维护性。
5.多态性的复杂度。
多态性的复杂度是指通过多个不同形式来表示同一元素的能力，包括类的代表性、接口和泛型等。
以上指标是衡量面向对象软件复杂度的主要因素，因此必须考虑各种不同因素的充分影响。
接下来，我们将结合具体案例来探讨如何针对不同的复杂度度量因素进行实际操作。
案例分析：以在线图书管理系统为例，通过对不同复杂度因素的度量来评价其软件复杂度。
1.类的复杂度在此示例中，系统中会有图书类和用户类等多个类，每个类中都包含多个方法。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
—61—开源软件中结构复杂度的度量方法黄雅菁，高建华(上海师范大学计算机科学与工程系，上海 200234)摘 要：针对大型开源软件的复杂性，提出一种基于随机图和结构熵的开源软件结构复杂度的度量方法。
将开源软件中的软件包抽象成点，将软件包之间的依赖关系抽象成有向边，建立随机图，并引入结构熵的概念。
结合随机图的特性和结构熵度量开源软件的耦合度和内聚度。
利用该方法进行实例分析，结果表明，随着开源软件按版本发展，软件耦合度和内聚度不断增长。
关键词：开源软件；随机图；结构熵；耦合；内聚Measure Method of Structural Complexity in Open Source SoftwareHUANG Ya-jing, GAO Jian-hua(Department of Computer Science and Engineering, Shanghai Normal University, Shanghai 200234)【Abstract 】 In order to study the complexity of the large-scale open source software, this paper models the packages in the open source software as vertices and the dependency relationships among these packages as directed edges. It uses random graph measure and structure entropy to propose a new method of measuring structural complexity of open source software. It uses the method by the fact to investigate that as the release of the open source software evolves, the coupling and cohesion grow from lower to higher.【Key words 】open source software; random graph; structure entropy; coupling; cohesion计 算 机 工 程 Computer Engineering 第36卷 第10期Vol.36 No.10 2010年5月May 2010·软件技术与数据库·文章编号：1000—3428(2010)10—0061—03文献标识码：A中图分类号：TP311.51 概述由于免费开放源代码等优点，开源软件得到广泛应用。
但开源软件数据量大，允许开发者自由修改程序，使开源软件复杂性越来越高。
软件结构复杂性直接影响软件维护的代价和精力。
软件系统的复杂度取决于软件内部结构各子系统之间的控制流与数据流的复杂程度，它包括算法复杂度和结构复杂度。
本文所提到的复杂度是指结构复杂度。
软件复杂度度量的方法[1-2]已被广泛研究，从不同角度量化了软件的一些特性，但对大型的开源软件不适用。
国内外研究工作者[3-4]已经将随机图论应用在开源软件的管理。
经典的随机图特性只能解释某些结构特性，但很难直接应用在软件包管理上。
例如，度分析能说明软件包在互相依赖中的选择机制，但不能用来定义整个软件的复杂度。
文献[5]定义了基于随机图的有向图复杂度参数，该参数超越了简单的直接依赖关系，但不能反映软件包之间的紧密程度。
本文以随机图论为基础，把开源软件子包抽象成点，把子包之间的依赖关系抽象成有向边，建立随机图。
基于随机图的特性度量开源软件的耦合度，并引入结构熵的概念度量开源软件内聚度，提出一种基于随机图和结构熵度量开源软件结构复杂度的方法。
应用该方法研究和分析了开源软件按版本发、耦合度和内聚度纵向变化情况。
2 软件结构复杂度度量结构复杂度度量的目标要能反映模块内部结构的复杂度以及模块间接口的复杂度，决定于代码基本的层级组织，先开始于方法层，然后通过抽象层移植[6]。
在方法层，评估软件系统结构复杂度是通过度量圈复杂度，即通过代码主体可执行路径的条数。
圈复杂度的值越高，方法的代码就越复杂。
在抽象层(例如类、包、元件)，评估软件系统结构复杂度是通过度量耦合和内聚。
耦合是指2个子系统之间的依赖数目，内聚是指子系统内部的依赖数目。
当运行大型复杂代码，传统的圈复杂度、耦合和内聚的度量没有考虑设计依赖的影响。
The Structure 101度量框架(/procucts/structure101/index.php)能提供软件在方法层和抽象层设计依赖关系，这种关系是运行时的依赖关系，度量框架界面如图1所示。
图1 The Structure 101度量框架界面本文主要研究包的级别，评估开源软件结构复杂度主要通过度量耦合和内聚，利用The Structure 101框架度量开源软件可得其包之间的依赖关系。
在图1中，区域1显示包的层级关系，即包及其下的子包；区域2显示包两两之间的依基金项目：国家自然科学基金资助项目(60673067)；上海市教育委员会科研创新基金资助项目(0922135)作者简介：黄雅菁(1983－)，女，硕士研究生，主研方向：开源软件技术，软件工程；高建华，教授、博士收稿日期：2009-11-20 E-mail ：yajing_huang@—62—赖关系；区域3显示包之间的依赖关系。
3 基于随机图的耦合度度量以随机图论为基础，首先把开源软件子包抽象成点，把子包之间的依赖关系抽象成有向边，建立随机图。
文献[5]定义了基于随机图的有向图复杂度参数，即该软件包运行时所需要的所有其他软件包。
但这个参数只能反映软件包之间的依赖关系，不能反映软件包之间的紧密程度。
因此，可以使用这个复杂度参数度量开源软件的耦合度。
以图2的软件包1为例，软件包1的耦合度为4。
对应于图，某个节点耦合度的定义可以等价于以该节点为根节点按边的方向生长的树中子节点的个数。
整个图的耦合度定义为所有软件包耦合度的平均值，即开源软件的耦合度。
图2 软件耦合度实例4 基于结构熵的内聚度度量开源软件的内聚度是指开源软件中软件包之间关系的密切程度。
为了度量这种关系，引入了结构熵的概念。
对于一个广义的系统来说，熵可作为状态的混乱性或无序性的度量。
结构熵的特性取决于系统的组织结构，组织化程度越高，结构熵越小；反之，结构熵越大[7]。
如果一个系统X 有n 个子系统X 1, X 2,…, X n ，子系统X i 与X j 有关联，则g ij =1，否则g ij =0。
令N (i )=1nij j g =∑；联结强度ρ(i )=1()()n j N i N j =∑。
系统X 的结构熵为H =-1()ln ()ni i i ρρ=∑，其中，1()ni i ρ=∑=1。
根据结构熵的概念，有如下定义：如果一个开源软件S 有n 个子包P 1, P 2,…, P n ，集合P _DEP 记录P i 所依赖的其他软件包的集合。
令N (i )=1|_()|nk k P DEP P =∑；联结强度ρ(P i )=1|_()||_()|i nk k P DEP P P DEP P =∑。
其中，||表示集合中元素的个数。
软件S 中包之间的内聚度为 Cohesion (P _P )=-1|_()|()ln ()*ln ni i i i P DEP P P P n nρρ=∑内聚度Cohesion (P _P )的取值范围为[0,1]。
当内聚度为0时，表示2个软件包没有任何依赖关系，包之间的内聚度最小；当内聚度为1时，说明任意2个包之间都具有依赖关系，包之间的内聚度最大。
5 基于随机图和结构熵的结构复杂度度量基于随机图和结构熵的开源软件结构复杂度度量方法 如下：(1)在开源软件网站()下载待测量的开源软件。
(2)用The Structure 101测量开源软件的核心包，得到开源软件核心包中子包的信息。
(3)将核心包里的子包抽象成点，把子包之间的依赖关系抽象成有向边，建立子包之间的随机图。
(4)利用有向图的复杂度参数，计算随机图中各节点的耦合度，各节点的平均耦合度近似为该开源软件的耦合度。
(5)根据随机图中的依赖关系结合结构熵的概念，计算开源软件软件包之间的内聚度。
6 实例分析本节以开源软件JFreeChart 的0.8.1版本为例进行分析，描述基于随机图和结构熵的开源软件结构复杂度度量方法：(1)用The Structure 101测量开源软件JFreeChart 的核心包org.jfree.chart ，得到8个软件子包以及子包之间的依赖关系，每个包以数值标识，如表1所示。
表1 核心包org.jfree.chart 中子包之间的依赖关系包名标识值依赖包demo 1 chart,data,combination,tooltips ui 2 chart combination 3Chart,eventdata 4 - chart 5 event,tooltips,ui,combination event 6ui tooltips 7 - jdbc 8-(2)将核心包中的子包抽象成点，子包之间的依赖关系抽3所示。
图3 核心包org.jfree.chart 中子包之间的随机图(3)由图3计算耦合度，忽略孤立包的影响，首先计算各节点的耦合度，软件的耦合度近似为各个节点耦合度的平均值。
求得耦合度为2.86，如表2所示。
表2 图3的耦合度节点耦合度1 62 43 34 05 46 37 08 孤立 平均值2.86(4)由图3计算内聚度，首先计算联结强度，ρ(P i )=1|_()||_()|i nk k P DEP P P DEP P =∑。
P_DEP 记录P i 所依赖的其它软件包的集合，则|P _DEP (P i )|大小等于各节点的耦合度。
这样很容易求得各节点的联合强度，如表3所示。
表3 图3的联结强度节点联结强度1 0.32 0.23 0.154 05 0.26 0.157 0 8孤立—63—根据第4节软件S 中包之间的内聚度定义，求得内聚度为0.39。
(5)软件复杂度会随着版本变化，软件包依赖关系随着版本发展变成一个随时间演化生长的图。
统计了JFreeChart 主要版本核心包org.jfree.chart 中子包的数量。
如图4所示，软件包总数随着版本发展而增长，只在0.9.5版本~ 0.9.10版本之间有微弱减少的趋势。
0.9.01086422018161412软件主要版本软件包数量1.0.101.0.51.0.00.9.200.9.150.9.100.9.5图4 主要版本软件软件包数量变化利用上述方法计算JFreeChart 主要版本的耦合度和内聚度。