模数运算与三元运算

Question

我需要迭代n对整数：(0，1)，(1，2)，(2，3) .(n-2，n-1)，(n-1，0)

做这件事最好的方法是什么？

1. 使用模块化操作： 对于(int i= 0；i< n；i++){ int a= i；int b= (i + 1)%n //MaaaanyLinesOfDoSomethingWithAAndB }
2. 使用三元运算： 对于(int i= 0；i< n；i++){ int a= i；int b= (i +1 == n?0:i+ 1) //MaaaanyLinesOfDoSomethingWithAAndB }
3. 或者： 对于(int i= 0；i< n；i++){ int a= i；int b= (i +1 >= n?0:i+ 1) //MaaaanyLinesOfDoSomethingWithAAndB }
4. 另一个主意？让我们假设有做某事的行，如果我们做(0，1)，(1，2)，(2，3) .(n-2，n-1)部分和(n-1，0)部分.

哪种操作最有效？

编辑#1对不起，我想我没有正确地问我的问题。我想知道哪个操作员表现得更快(例如秒或时钟滴答)。我还决定做一些小实验，只需用clock()函数来测量它。这是我的密码：

#include <time.h>
#include <limits.h>
#include <string>
#include <iostream>
using namespace std;

typedef void (*fun) (int a);

void DoSomething(int i){
    int a = i;
}

void ModuloOperation (int n){
    for (int i = 0; i < n; i++)
        DoSomething((i + 1) % n);
}

void TernaryEqual (int n){
    for (int i = 0; i < n; i++)
        DoSomething(i + 1 == n ? 0 : i + 1);
}

void TernaryBiggerEqual (int n){
    for (int i = 0; i < n; i++)
        DoSomething(i + 1 >= n ? 0 : i + 1);
}

void SplitIntoTwoParts (int n){
    for (int i = 0; i < n - 1; i++)
        DoSomething(i + 1);
    DoSomething(n - 1);
}

int main(){

    const int n = INT_MAX;

    string testNames[] = {
        "Modulo", 
        "Trenary equal", 
        "Trenary bigger equal", 
        "Split into two parts"
    };

    fun tests[] = {
        ModuloOperation, 
        TernaryEqual, 
        TernaryBiggerEqual, 
        SplitIntoTwoParts
    };

    clock_t t;

    for (int i = 0; i < sizeof(testNames)/sizeof(testNames[0]); i++){

        t = clock();
        tests[i](n);
        t = clock() - t;

        cout<<testNames[i]<<": "<<((float)t)/CLOCKS_PER_SEC<<" seconds\n\n";
    }

    return 0;
}

这是一个输出

模数: 53.867秒 当量: 36.684秒 更大的当量: 37.299秒 分成两部分: 31.37秒

因此，似乎P.s.w.g的想法不仅是最干净的，而且是最好的。

再次，为我的错误感到抱歉，我不是母语，我仍然在学习。

Answer 1

你说过，如果你把“maaaany”这句台词分开，它看起来会很难看。上述选项中没有一个是特别漂亮的。因此，也许最好将这个丑陋的逻辑封装在一个方法中，并在循环中使用一些更优雅的代码。

为了提高可读性，我可能会这么说：

for (int i = 0; i < n - 1; i++){
    DoStuff(i, i + 1);
}
DoStuff(n - 1, 0);

// elsewhere
void DoStuff(int a, int b)
{
    //MaaaanyLinesOfDoSomethingWithAAndB
}

如果“maaaany”行需要使用一些局部变量，并且不希望将它们全部传递给DoStuff方法，那么您可能需要考虑使用闭包，尽管它对代码的可读性的帮助几乎与正确的函数分解一样多。就像这样：

Action<int, int> doStuff = (a, b) =>
{
    //MaaaanyLinesOfDoSomethingWithAAndB
};

for (int i = 0; i < n - 1; i++){
    doStuff(i, i + 1);
}
doStuff(n - 1, 0);

或者，您可能需要将“maaaany”行重构为一个单独的工人类，但如果不了解这些行中的更多内容，就很难说了。