看看这两个循环

 const int arrayLength = ...

    public void RunTestFrom0()
    {
        int sum = 0;
        for (int i = 0; i < arrayLength; i++)
            for (int j = 0; j < arrayLength; j++)
                for (int k = 0; k < arrayLength; k++)
                    for (int l = 0; l < arrayLength; l++)
                        for (int m = 0; m < arrayLength; m++)
                        {
                            sum += myArray[i][j][k][l][m];
                        }
    }

    public void RunTestFrom1()
    {
        int sum = 0;
        for (int i = 1; i < arrayLength; i++)
            for (int j = 1; j < arrayLength; j++)
                for (int k = 1; k < arrayLength; k++)
                    for (int l = 1; l < arrayLength; l++)
                        for (int m = 1; m < arrayLength; m++)
                        {
                            sum += myArray[i][j][k][l][m];
                        }
    }

    public void RunTestFrom2()
    {
        int sum = 0;
        for (int i = 2; i < arrayLength; i++)
            for (int j = 2; j < arrayLength; j++)
                for (int k = 2; k < arrayLength; k++)
                    for (int l = 2; l < arrayLength; l++)
                        for (int m = 2; m < arrayLength; m++)
                        {
                            sum += myArray[i][j][k][l][m];
                        }
    }

    public void RunTestConstStartConstEnd()
    {
        int sum = 0;
        for (int i = constStart; i < constEnd; i++)
            for (int j = constStart; j < constEnd; j++)
                for (int k = constStart; k < constEnd; k++)
                    for (int l = constStart; l < constEnd; l++)
                        for (int m = constStart; m < constEnd; m++)
                        {
                            sum++;
                        }
    }

最佳答案

更新

在我看来，这似乎是 尝试优化失败的结果。抖动 ，不是编译器。总之，如果抖动可以确定下限是一个常数，它会做一些不同的事情，结果实际上更慢。我的结论的基础需要一些证明，所以请耐心等待。或者，如果您不感兴趣，请阅读其他内容!

在测试了四种不同的设置循环下界的方法后，我得出了这个结论:

class Program {
    static void Main(string[] args) {
        List<double> testResults = new List<double>();
        Stopwatch sw = new Stopwatch();
        int upperBound = int.Parse(args[0]) + 1;
        int tests = int.Parse(args[1]);
        int lowerBound = int.Parse(args[2]);   // THIS LINE CHANGES
        int sum = 0;

        for (int iTest = 0; iTest < tests; iTest++) {
            sum = 0;
            GC.Collect();
            sw.Reset();
            sw.Start();
            for (int lvl1 = lowerBound; lvl1 < upperBound; lvl1++)
                for (int lvl2 = lowerBound; lvl2 < upperBound; lvl2++)
                    for (int lvl3 = lowerBound; lvl3 < upperBound; lvl3++)
                        for (int lvl4 = lowerBound; lvl4 < upperBound; lvl4++)
                            for (int lvl5 = lowerBound; lvl5 < upperBound; lvl5++)
                                sum++;
            sw.Stop();
            testResults.Add(sw.Elapsed.TotalMilliseconds);
        }

        double avg = testResults.Average();
        double stdev = testResults.StdDev();
        string fmt = "{0,13} {1,13} {2,13} {3,13}"; string bar = new string('-', 13);
        Console.WriteLine();
        Console.WriteLine(fmt, "Iterations", "Average (ms)", "Std Dev (ms)", "Per It. (ns)");
        Console.WriteLine(fmt, bar, bar, bar, bar);
        Console.WriteLine(fmt, sum, avg.ToString("F3"), stdev.ToString("F3"),
                          ((avg * 1000000) / (double)sum).ToString("F3"));
    }
}

public static class Ext {
    public static double StdDev(this IEnumerable<double> vals) {
        double result = 0;
        int cnt = vals.Count();
        if (cnt > 1) {
            double avg = vals.Average();
            double sum = vals.Sum(d => Math.Pow(d - avg, 2));
            result = Math.Sqrt((sum) / (cnt - 1));
        }
        return result;
    }
}

        int lowerBound = 0; // or 1, 2, or 3

        int lowerBound = Ext.Confuser<int>(0); // or 1, 2, or 3

public static T Confuser<T>(T d) {
    decimal d1 = (decimal)Convert.ChangeType(d, typeof(decimal));
    List<decimal> L = new List<decimal>() { d1, d1 };
    decimal d2 = L.Average();
    if (d1 - d2 < 0.1m) {
        return (T)Convert.ChangeType(d2, typeof(T));
    } else {
        // This will never actually happen :)
        return (T)Convert.ChangeType(0, typeof(T));
    }
}

1: Lower bound hard-coded in all loops: 
 Program    Iterations  Average (ms)  Std Dev (ms)  Per It. (ns)
-------- ------------- ------------- ------------- -------------
 Looper0     345025251       267.813         1.776         0.776
 Looper1     312500000       344.596         0.597         1.103
 Looper2     282475249       311.951         0.803         1.104
 Looper3     254803968       282.710         2.042         1.109

2: Lower bound supplied at command line: 
 Program    Iterations  Average (ms)  Std Dev (ms)  Per It. (ns)
-------- ------------- ------------- ------------- -------------
  Looper     345025251       269.317         0.853         0.781
  Looper     312500000       244.946         1.434         0.784
  Looper     282475249       222.029         0.919         0.786
  Looper     254803968       201.238         1.158         0.790

3: Lower bound hard-coded but copied to local variable: 
 Program    Iterations  Average (ms)  Std Dev (ms)  Per It. (ns)
-------- ------------- ------------- ------------- -------------
LooperX0     345025251       267.496         1.055         0.775
LooperX1     312500000       345.614         1.633         1.106
LooperX2     282475249       311.868         0.441         1.104
LooperX3     254803968       281.983         0.681         1.107

4: Lower bound hard-coded but ground through Confuser: 
 Program    Iterations  Average (ms)  Std Dev (ms)  Per It. (ns)
-------- ------------- ------------- ------------- -------------
LooperZ0     345025251       266.203         0.489         0.772
LooperZ1     312500000       241.689         0.571         0.774
LooperZ2     282475249       219.533         1.205         0.777
LooperZ3     254803968       198.308         0.416         0.778

关于c# - 循环从 0 开始比循环从 1 开始快？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/9739578/