oclint规则 Size（大小）

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.