C 循环的执行速度随位置的变化而变化

A版：

#include<time.h>
#include<stdio.h>
int main()
{

time_t start = time(0); //denote start time
int i,j; // initialize ints
static double dst[4096][4096]; //initialize arrays
static double src[4096][4096]; //
for(i=0; i<4096; ++i){
    for(j=0; j<4096; ++j){
        dst[i][j] = src[i][j];
}
    }
time_t end = time(0); //denote end time


double time = difftime(end, start); //take difference of start and end time to determine elapsed time
printf("Test One: %fms\n",time);

}

#包括
#包括
int main（）
{
time_t start=time（0）；//表示开始时间
int i，j；//初始化int
静态双dst[4096][4096]；//初始化数组
静态双src[4096][4096]//
对于（i=0；i
#包括
#包括
int main（）
{
time_t start=time（0）；//表示开始时间
int i，j；//初始化int
静态双dst[4096][4096]；//初始化数组
静态双src[4096][4096]//
对于（j=0；j
#包括
#包括
int main（）
{
time_t start=time（0）；//表示开始时间
int i，j；//初始化int
静态双dst[4096][4096]；//初始化数组
静态双src[4096][4096]//
对于（j=0；j
#包括
#包括
int main（）
{
time_t start=time（0）；//表示开始时间
int i，j；//初始化int
静态双dst[4096][4096]；//初始化数组
静态双src[4096][4096]//
对于（j=0；j
#包括
#包括
int main（）
{
time_t start=time（0）；//表示开始时间
int i，j；//初始化int
静态双dst[4096][4096]；//初始化数组
静态双src[4096][4096]//
对于代码中的（j=0；j，循环意味着“逐个遍历同一行中的地址，然后转到下一行”。但如果反转i和j的位置，这意味着“逐个遍历同一列中的地址，转到下一列”

在C语言中，多维数组被放在线性地址空间中，逐字节，然后逐行，所以在你的例子中，dst[i][j]=src[i][j]
意味着
*（dst+4096*i+j）=*（src+4096*i+j）
：

相反的
i
和
j
表示：

*(dst + 4096 * 0 + 0) = *(src + 4096 * 0 + 0);
*(dst + 4096 * 1 + 0) = *(src + 4096 * 1 + 0);
*(dst + 4096 * 2 + 0) = *(src + 4096 * 2 + 0);
//...

因此，在第二种情况下，额外的1秒是以非连续方式访问内存造成的

您不需要自己进行时间计算，因为您可以在linux/UNIX上使用“time”命令运行程序：

$ time ./loop

这两种情况下我的linux机器上的结果：

$ time ./loop_i_j

real    0m0.244s
user    0m0.062s
sys     0m0.180s

$ time ./loop_j_i

real    0m1.072s
user    0m0.995s
sys     0m0.073s

在您的代码中，循环意味着“逐个遍历同一行中的地址，然后转到下一行”。但如果反转i和j的位置，这意味着“逐个遍历同一列中的地址，转到下一列”

在C语言中，多维数组被放在线性地址空间中，逐字节，然后逐行，所以在你的例子中，dst[i][j]=src[i][j]
意味着
*（dst+4096*i+j）=*（src+4096*i+j）
：

相反的
i
和
j
表示：

*(dst + 4096 * 0 + 0) = *(src + 4096 * 0 + 0);
*(dst + 4096 * 1 + 0) = *(src + 4096 * 1 + 0);
*(dst + 4096 * 2 + 0) = *(src + 4096 * 2 + 0);
//...

因此，在第二种情况下，额外的1秒是以非连续方式访问内存造成的

您不需要自己进行时间计算，因为您可以在linux/UNIX上使用“time”命令运行程序：

$ time ./loop

这两种情况下我的linux机器上的结果：

$ time ./loop_i_j

real    0m0.244s
user    0m0.062s
sys     0m0.180s

$ time ./loop_j_i

real    0m1.072s
user    0m0.995s
sys     0m0.073s

在您的代码中，循环意味着“逐个遍历同一行中的地址，然后转到下一行”。但如果反转i和j的位置，这意味着“逐个遍历同一列中的地址，转到下一列”

在C语言中，多维数组被放在线性地址空间中，逐字节，然后逐行，所以在你的例子中，dst[i][j]=src[i][j]
意味着
*（dst+4096*i+j）=*（src+4096*i+j）
：

相反的
i
和
j
表示：

*(dst + 4096 * 0 + 0) = *(src + 4096 * 0 + 0);
*(dst + 4096 * 1 + 0) = *(src + 4096 * 1 + 0);
*(dst + 4096 * 2 + 0) = *(src + 4096 * 2 + 0);
//...

因此，在第二种情况下，额外的1秒是以非连续方式访问内存造成的

您不需要自己进行时间计算，因为您可以在linux/UNIX上使用“time”命令运行程序：

$ time ./loop

这两种情况下我的linux机器上的结果：

$ time ./loop_i_j

real    0m0.244s
user    0m0.062s
sys     0m0.180s

$ time ./loop_j_i

real    0m1.072s
user    0m0.995s
sys     0m0.073s

在您的代码中，循环意味着“逐个遍历同一行中的地址，然后转到下一行”。但如果反转i和j的位置，这意味着“逐个遍历同一列中的地址，转到下一列”

在C语言中，多维数组被放在线性地址空间中，逐字节，然后逐行，所以在你的例子中，dst[i][j]=src[i][j]
意味着
*（dst+4096*i+j）=*（src+4096*i+j）
：

相反的
i
和
j
表示：

*(dst + 4096 * 0 + 0) = *(src + 4096 * 0 + 0);
*(dst + 4096 * 1 + 0) = *(src + 4096 * 1 + 0);
*(dst + 4096 * 2 + 0) = *(src + 4096 * 2 + 0);
//...

因此，在第二种情况下，额外的1秒是以非连续方式访问内存造成的

您不需要自己进行时间计算，因为您可以在linux/UNIX上使用“time”命令运行程序：

$ time ./loop

这两种情况下我的linux机器上的结果：

$ time ./loop_i_j

real    0m0.244s
user    0m0.062s
sys     0m0.180s

$ time ./loop_j_i

real    0m1.072s
user    0m0.995s
sys     0m0.073s

你提供的相当正式的解释可能会重复，这表明这是一个家庭作业，而不是一个实际的编程问题。（当你交作业时，别忘了记上学分。）这实际上是我学习计划的一部分，不是课堂作业。这是为了我的个人知识和将来的应用。我没有问题，所以对于答案，我只是不知道清楚的解释是什么。你提供的相当正式的解释可能重复表明这是一个家庭作业，而不是n一个实用的编程问题。（当你交作业时，别忘了记学分。）这实际上是我学习计划的一部分，不是课堂作业。这是为了我的个人知识和将来的应用。我没有问题，所以对于答案，我只是不知道清楚的解释是什么。你提供的相当正式的解释可能重复表明这是一个家庭作业，而不是n一个实用的编程问题。（当你交作业时，别忘了记学分。）这实际上是我学习计划的一部分，不是课堂作业。这是为了我的个人知识和将来的应用。我没有问题，所以对于答案，我只是不知道清楚的解释是什么。你提供的相当正式的解释可能重复表明这是一个家庭作业，而不是一道实用的编程题。（交作业时别忘了记学分。）它实际上是我学习计划的一部分，而不是课堂作业。它是为了我的个人知识和能力