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

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表达式作为参数的函数。 它会做嵌套循环并应用你作为参数传递的“廉价东西”或“昂贵的东西”。

你可以称之为“便宜的东西”，一次是“昂贵的东西”。