为什么单独循环中的元素加法比组合循环中的要快得多？

当添加两个以上的数组时，与单独添加元素相比，逐步添加元素的单独循环证明具有更好的性能。

为了测试以上语句，两个代码块添加了4个数组元素，即数组a与b和c与d。第一个代码块使用组合循环将它们相加，而第二个代码块使用两个不同的for循环。在两个程序中都使用时钟来测量执行循环所花费的时间。

使用组合循环

// C program to illustrate
// performance of loops
#include 
using namespace std;
int main()
{
    const int n = 100000;
  
    double* a1 = (double*)malloc(n * sizeof(double));
    double* b1 = (double*)malloc(n * sizeof(double));
    double* c1 = (double*)malloc(n * sizeof(double));
    double* d1 = (double*)malloc(n * sizeof(double));
  
    // Zero the data to prevent any chance of denormals.
    memset(a1, 0, n * sizeof(double));
    memset(b1, 0, n * sizeof(double));
    memset(c1, 0, n * sizeof(double));
    memset(d1, 0, n * sizeof(double));
    clock_t start = clock();
  
    int c = 0;
    while (c++ < 10000) {
        for (int j = 0; j < n; j++) {
            a1[j] += b1[j];
            c1[j] += d1[j];
        }
    }
    clock_t end = clock();
    cout << "seconds = " << (double)(end - start) / CLOCKS_PER_SEC << endl;
  
    return 0;
}

输出 ：

seconds = 2.47865

使用单独的循环

// C program to illustrate
// performance of loops
#include 
using namespace std;
int main()
{
    const int n = 100000;
  
    double* a1 = (double*)malloc(n * sizeof(double));
    double* b1 = (double*)malloc(n * sizeof(double));
    double* c1 = (double*)malloc(n * sizeof(double));
    double* d1 = (double*)malloc(n * sizeof(double));
  
    // Zero the data to prevent any chance of denormals.
    memset(a1, 0, n * sizeof(double));
    memset(b1, 0, n * sizeof(double));
    memset(c1, 0, n * sizeof(double));
    memset(d1, 0, n * sizeof(double));
    clock_t start = clock();
  
    int c = 0;
  
    while (c++ < 10000) {
  
        for (int j = 0; j < n; j++) {
            a1[j] += b1[j];
        }
        for (int j = 0; j < n; j++) {
            c1[j] += d1[j];
        }
    }
  
    clock_t end = clock();
    cout << "seconds = " << (double)(end - start) / CLOCKS_PER_SEC << endl;
  
    // system("pause");
    return 0;
}

输出 ：

seconds = 2.07937

注意：实际输出时间取决于所使用的编译器

从上面的示例中我们可以看到，单独的循环比组合的循环要快。这样做的原因是，假设采用简单的LIFO缓存策略，单独的循环将首先导致a和b加载到RAM中，然后完全在RAM中工作。当第二个循环开始时，然后将c和d从磁盘加载到RAM中并进行操作。因此，将阵列一次加载到内存中。

组合循环每次循环时将分页出两个数组，并在其他两个页面中分页。因此，与循环一次加载数组并进行处理的单独循环相比，组合循环要慢得多，因为分页输出必须重复进行。

想要从精选的最佳视频中学习和练习问题，请查看《基础知识到高级C的C基础课程》。