C++代码优化，复杂度太高，无法通过clang-tidy检查，用什么办法可以优=化

我看到一段代码是使用C++写的，switch + for，如下

enum class MO { A = 0, B, C};
int test(MO m) {
    switch (m) {
        case MO::A:
            for (int i = 0; i < 10; i++) {
                for (int y = 0; y < 10; y++) {
                    //TODO
                }
            }
            if(xxxx){
                return -1;
            }
            for (int i = 0; i < 10; i++) {
                for (int y = 0; y < 10; y++) {
                    //TODO
                }
            }
            break;
        case MO::B:
            for (int i = 0; i < 10; i++) {
                for (int y = 0; y < 10; y++) {
                    //TODO
                }
            }
            if(xxxx){
                return -1;
            }
            for (int i = 0; i < 10; i++) {
                for (int y = 0; y < 10; y++) {
                    //TODO
                }
            }
            break;
        case MO::C:
            for (int i = 0; i < 10; i++) {
                for (int y = 0; y < 10; y++) {
                    //TODO
                }
            }
            if(xxxx){
                return -1;
            }
            for (int i = 0; i < 10; i++) {
                for (int y = 0; y < 10; y++) {
                    //TODO
                }
            }
            break;
        default:
            break;
    }
    return 0;
}
int main() {
    test(MO::A);
    return 0;
}

里面有switch，也有双层for,大概结构如上，模拟的伪代码，这样的代码 有没有什么办法优化，它的复杂度太高
导入clang-tidy检查无法通过。用什么办法优化，补充，每个for循环次数里面的内容是不相同的，另外，每个case是两个"双层for"，两个“双层for”之间有return函数的语句。

for (int i = 0; i < 10; i++) {
                for (int y = 0; y < 10; y++) {
                    //TODO 1
                }
            }
            for (int i = 0; i < 10; i++) {
                for (int y = 0; y < 10; y++) {
                    //TODO 2
                }
            }

这样的代码，在case A, B ,C里都有，
如果case A, B, C三个里面的TODO差异比较大的话，可以分开抽成函数，如果差异比较小，那就弄成一个

差异大：

enum class MO { A = 0, B, C};
void proc_A1() {
            //TODO 1
}
void proc_A2() {
            //TODO 2
}
void proc_B1() {
            //TODO 1
}
void proc_B2() {
            //TODO 2
}
void proc_C1() {
            //TODO 1
}
void proc_C2() {
            //TODO 2
}
int test(MO m) {
    for (int i = 0; i < 10; i++) {
        for (int y = 0; y < 10; y++) {
            switch (m) {
                case MO::A:
                    proc_A1();
                    break;
                case MO::B:
                    proc_B1();
                    break;
                case MO::C:
                    proc_C1();
                    break;
                default:
                    break;
            }
        }
    }
    for (int i = 0; i < 10; i++) {
        for (int y = 0; y < 10; y++) {
            switch (m) {
                case MO::A:
                    proc_A2();
                    break;
                case MO::B:
                    proc_B2();
                    break;
                case MO::C:
                    proc_C2();
                    break;
                default:
                    break;
            }
        }
    }
    return 0;
}
int main() {
    test(MO::A);
    return 0;
}

差异小：

enum class MO { A = 0, B, C};
void proc_member1(int i) {
    // TODO 1:
}
void proc_member2(int i) {
    // TODO 2:
}

int test(MO m) {

    for (int i = 0; i < 10; i++) {
        for (int y = 0; y < 10; y++) {
             proc_member1(m)
    }

    for (int i = 0; i < 10; i++) {
        for (int y = 0; y < 10; y++) {
             proc_member2(m)
    }

    return 0;
}
int main() {
    test(MO::A);
    return 0;
}

重复代码过多，尽量提取公共方法处理；同时，建议在for循环中尽量不要去调用数据库，可以采用统一查询再次组合的形式完成数据处理

这段代码里有很多重复的部分，可以通过函数封装来优化代码。如果要在同一个代码块内重复执行相同的操作，比如两次嵌套循环，可以将这两次嵌套循环抽象成一个函数。只需要调用两次该函数即可，这样就可以大大减少代码冗余。

针对这段代码，可以抽象成一个函数实现嵌套循环的功能，然后在switch语句中调用该函数。这样就可以将代码简化为一个函数的调用，减少了代码的冗余。

优化后的代码如下：

c

enum class MO { A = 0, B, C};
void loop_operation() {
    for (int i = 0; i < 10; i++) {
        for (int y = 0; y < 10; y++) {
            //TODO
        }
    }
    for (int i = 0; i < 10; i++) {
        for (int y = 0; y < 10; y++) {
            //TODO
        }
    }
}
int test(MO m) {
    switch (m) {
        case MO::A:
            loop_operation();
            break;
        case MO::B:
            loop_operation();
            break;
        case MO::C:
            loop_operation();
            break;
        default:
            break;
    }
    return 0;
}
int main() {
    test(MO::A);
    return 0;
}

三个case的内部都是相同的双重循环，每次都循环10次。可以把这部分提取出来作为一个独立的函数，从而减少代码重复，使代码结构更清晰。

另外，为了减少复杂度，可以考虑使用更高效的算法代替双重循环。例如，在特定的情况下，使用预处理的数据结构或利用算法的性质等，都可以提高程序的效率。

enum class MO { A = 0, B, C};

void process() {
    for (int i = 0; i < 10; i++) {
        for (int y = 0; y < 10; y++) {
            //TODO
        }
    }
    for (int i = 0; i < 10; i++) {
        for (int y = 0; y < 10; y++) {
            //TODO
        }
    }
}

int test(MO m) {
    switch (m) {
        case MO::A:
            process();
            break;
        case MO::B:
            process();
            break;
        case MO::C:
            process();
            break;
        default:
            break;
    }
    return 0;
}

int main() {
    test(MO::A);
    return 0;
}

希望对你有所帮助，代码中，我们把公共代码抽取到了一个 loop 函数中，并在三个 case 语句中重复调用了该函数。这样代码变得更加简洁，容易维护。

enum class MO { A = 0, B, C};

void loop(int iterations) {
    for (int i = 0; i < iterations; i++) {
        for (int y = 0; y < iterations; y++) {
            //TODO
        }
    }
}

int test(MO m) {
    switch (m) {
        case MO::A:
        case MO::B:
        case MO::C:
            loop(10);
            loop(10);
            break;
        default:
            break;
    }
    return 0;
}

int main() {
    test(MO::A);
    return 0;
}