Question

我有一个带有嵌套循环的方法，如下所示，在其中我执行一些计算上昂贵的事情，以及一些计算上便宜的事情：

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
        }
    }
}

当前，我只调用一次我的方法。但是我需要将便宜的东西与昂贵的东西分开。问题是，如果开发两个方法，则需要重复嵌套循环以及与之纠缠的大量代码。

我想知道是否有最佳实践或工具来帮助我将单个方法分解为两个方法而无需重复很多代码。或者，也许如果有一种解决方案，可以将廉价商品与昂贵商品分开，而无需将我的单一方法分解为两种方法？

Answer 1

我最终这样做：

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;
                }

            }
        }
    }

// ...

}

通过使用enum作为参数/参数和switch，现在我可以分别进行便宜和昂贵的工作，甚至尽管它们非常纠缠在嵌套循环中。

Answer 2

您可以创建一个以函数或lambda表达式为参数的函数。它将执行嵌套循环，并应用您作为参数传递的“便宜的东西”或“昂贵的东西”。

您将称其为“便宜的东西”和“昂贵的东西”。

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

2 个答案: