Size¶
高圈复杂度HighCyclomaticComplexity¶
Since: 0.4
圈复杂度(CyclomaticComplexity)是很常用的一种度量软件代码复杂程度的标准。这里所指的“代码复杂程度”并非软件内在业务逻辑的复杂程度，而是指代码的实现方式的复杂程度。有很多研究统计指出，圈复杂度高的代码中错误的可能性更大，维护的成本更高。
非常非常简单的说它就是统计一个函数有多少个分支(if, while,for,等等)，没有的话复杂度为一，每增加一个分支复杂度加一。让很多人不解的是，无论这些分支是并列还是嵌套，统统都是加一。
圈复杂度的作者McCabe，经过试验认为，圈复杂度在3~~7比较好的结构化方法。他还认为10是圈复杂度的一个合理化上限。
定义类: oclint-rules/rules/size/CyclomaticComplexityRule.cpp
Example:
void example(int a, int b, int c) // 1
{
if (a == b) // 2
{
if (b == c) // 3
{
}
else if (a == c) // 3
{
}
else
{
}
}
for (int i = 0; i < c; i++) // 4
{
}
switch(c)
{
case 1: // 5
break;
case 2: // 6
break;
default: // 7
break;
}
}
Thresholds:
- CYCLOMATIC_COMPLEXITY
- 圈复杂度阀值, 默认 10.
Suppress:
__attribute__((annotate("oclint:suppress[high cyclomatic complexity]")))
References:
McCabe (December 1976). “A Complexity Measure”. IEEE Transactions on Software Engineering: 308–320
太长的类 LongClass¶
Since: 0.6
复杂的事儿应该拆解分段去解决，降低复杂度，以及耦合.
定义类: oclint-rules/rules/size/LongClassRule.cpp
Example:
class Foo
{
void bar()
{
// 1001 lines of code
}
}
Thresholds:
- LONG_CLASS
- 类长度阀值, 默认行数 1000.
太长的行LongLine¶
Since: 0.6
一行代码太长，非常不利于阅读和维护，应该将代码转换为多行.
定义类: oclint-rules/rules/size/LongLineRule.cpp
Example:
void example()
{
int a012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789;
}
Thresholds:
- LONG_LINE
- 行长度阀值,默认值 100.
太长的方法 LongMethod¶
Since: 0.4
一个方法不应该太长，太长的方法影响后续的阅读，应该将每个方法都去做一个简单的事。
This rule is defined by the following class: oclint-rules/rules/size/LongMethodRule.cpp
Example:
void example()
{
cout << "hello world";
cout << "hello world";
// repeat 48 times
}
Thresholds:
- LONG_METHOD
- 方法长度阀值, 默认 50.
方法有效代码行太高HighNcssMethod¶
Since: 0.6
有效代码行，系统只计算实际的有效语句。空语句，空块，右括号或分号后的右括号会被忽略。一个被分解成多行的语句只计算一行。
定义类: oclint-rules/rules/size/NcssMethodCountRule.cpp
Example:
void example() // 1
{
if (1) // 2
{
}
else // 3
{
}
}
Thresholds:
- NCSS_METHOD
- 有效行代码阀值, 默认 30.
Suppress:
__attribute__((annotate("oclint:suppress[high ncss method]")))
嵌套块太深DeepNestedBlock¶
Since: 0.6
检查嵌套块是否超过指定的深度值.
This rule is defined by the following class: oclint-rules/rules/size/NestedBlockDepthRule.cpp
Example:
if (1)
{ // 1
{ // 2
{ // 3
}
}
}
Thresholds:
- NESTED_BLOCK_DEPTH
- 深度阀值，默认值 5.
高Npath复杂性 HighNPathComplexity¶
Since: 0.4
NPath复杂度是一个方法中各种可能的执行路径总和
一般把200作为考虑降低复杂度的临界点
定义类: oclint-rules/rules/size/NPathComplexityRule.cpp
Example:
void example()
{
// complicated code that is hard to understand
}
Thresholds:
- NPATH_COMPLEXITY
- Npath复杂度阀值, 默认 200.
Suppress:
__attribute__((annotate("oclint:suppress[high npath complexity]")))
References:
Brian A. Nejmeh (1988). “NPATH: a measure of execution path complexity and its applications”. Communications of the ACM 31 (2) p. 188-200
太多字段 TooManyFields¶
Since: 0.7
一个类定义太多的字段，表明它做了太多的事儿，应该去做抽象，重新设计.
定义类: oclint-rules/rules/size/TooManyFieldsRule.cpp
Example:
class c
{
int a, b;
int c;
// ...
int l;
int m, n;
// ...
int x, y, z;
void m() {}
};
Thresholds:
- TOO_MANY_FIELDS
- 最多字段阀值, 默认 20.
太多方法 TooManyMethods¶
Since: 0.7
一个类有太多的方法，证明他做了太多的事儿，不利于理解。应该考虑重构。
定义类: oclint-rules/rules/size/TooManyMethodsRule.cpp
Example:
class c
{
int a();
int b();
int c();
// ...
int l();
int m();
int n();
// ...
int x();
int y();
int z();
int aa();
int ab();
int ac();
int ad();
int ae();
};
Thresholds:
- TOO_MANY_METHODS
- 最多方法阀值, 默认 30.
太多参数 TooManyParameters¶
Since: 0.7
方法中有太多的参数是难以理解和后期维护的。应该尝试重构，或者使用 方法替换参数, 对象替换参数, or 使用完整对象.
定义类: oclint-rules/rules/size/TooManyParametersRule.cpp
Example:
void example(int a, int b, int c, int d, int e, int f,
int g, int h, int i, int j, int k, int l)
{
}
Thresholds:
- TOO_MANY_PARAMETERS
- 方法参数阀值, 默认 10.
References:
Fowler, Martin (1999). Refactoring: Improving the design of existing code. Addison Wesley.