时间戳

首页 > 解决方案 > 如何避免在嵌套循环中重复自己

c++ - 如何避免在嵌套循环中重复自己

问题描述

我有一个嵌套循环的方法，如下所示，我在其中做了一些计算上昂贵的东西和一些计算上便宜的东西：

for(int i = 0; i < SIZE_I; ++i) {
    // Do cheap stuff 1
    // Do computationally expensive stuff 1
    for(int j = 0; j < SIZE_J; ++j) {
        // Do cheap stuff 2
        // Do computationally expensive stuff 2
        for(int k = 0; k < SIZE_K; ++k) {
            // Do cheap stuff 3
            // Do computationally expensive stuff 3
        }
    }
}

目前，我调用我的方法一次。但我需要把便宜的东西和贵的东西分开。问题是，如果我开发两种方法，我将需要重复嵌套循环和大量与它们纠缠在一起的代码。

我想知道是否有最佳实践或工具可以帮助我将单个方法分解为两种方法，而无需重复大量代码。或者，如果有一种解决方案可以将便宜的东西和昂贵的东西分开，而无需将我的单一方法分解为两种方法？

标签： c++

解决方案

我最终这样做了：

enum CallStatus {
    CallStatus_Cheap = 0,
    CallStatus_Expensive
};

bool MyClass::MyMethod(MyClass::CallStatus callStatus)
{
    for(int i = 0; i < SIZE_I; ++i) {

        switch (callStatus) {
        case MyClass::CallStatus_Cheap:
            // Do cheap stuff 1
            break;
        case MyClass::CallStatus_Expensive:
            // Do computationally expensive stuff 1
            break;
        default:
            break;
        }

        for(int j = 0; j < SIZE_J; ++j) {

            switch (callStatus) {
            case MyClass::CallStatus_Cheap:
                // Do cheap stuff 2
                break;
            case MyClass::CallStatus_Expensive:
                // Do computationally expensive stuff 2
                break;
            default:
                break;
            }

            for(int k = 0; k < SIZE_K; ++k) {

                switch (callStatus) {
                case MyClass::CallStatus_Cheap:
                    // Do cheap stuff 3
                    break;
                case MyClass::CallStatus_Expensive:
                    // Do computationally expensive stuff 3
                    break;
                default:
                    break;
                }

            }
        }
    }

// ...

}

使用enumas argument/parameter and switch，现在我可以分别做便宜和昂贵的东西，即使它们非常纠缠在嵌套循环中。

推荐阅读