日常工作中，我们经常会用到循环遍历数组元素。不考虑只能使用某一特定方式的情况下，有人喜欢用数组下标遍历，有人则喜欢用指针遍历。那么这两者是否有性能差异呢？

我们先来看两个例子：

代码一：

/* a.c */
#include <stdio.h>
#include <sys/time.h>

int main(void)
{
    char arr[1024000];
    int i = 0;
    struct timeval begin, end;
    gettimeofday(&begin, NULL);
    for (; i < sizeof(arr); ++i) {
        arr[i] = 'c';
    }
    gettimeofday(&end, NULL);
    printf("%lu(us)\n", (end.tv_sec*1000000+end.tv_usec)-(begin.tv_sec*1000000+begin.tv_usec));
    for (i = 0; i < sizeof(arr); ++i)
        fprintf(stderr, "%c\n", arr[i]);
    return 0;
}

代码很简单，我们定义了一个比较长的字符数组，然后遍历每个元素进行赋值，并统计时长。最后遍历数组输出赋值内容。

我们如下执行命令：

$ gcc -o a a.c
$ ./a 2>/dev/null

那么循环赋值的执行时间如何呢？我取个平均一点的结果：

3227(us)

代码二

/* b.c */
#include <stdio.h>
#include <sys/time.h>

int main(void)
{
    char arr[1024000], *p = arr, *last = arr + sizeof(arr);
    int i;
    struct timeval begin, end;
    gettimeofday(&begin, NULL);
    for (; p < last; ++p) {
        *p = 'c';
    }
    gettimeofday(&end, NULL);
    printf("%lu(us)\n", (end.tv_sec*1000000+end.tv_usec)-(begin.tv_sec*1000000+begin.tv_usec));
    for (p = arr, last = arr+sizeof(arr); p < last; ++p)
        fprintf(stderr, "%c\n", *p);
    return 0;
}

与代码一相似，只是遍历时使用字符指针。

执行如下命令：

$ gcc -o b b.c
$ ./b 2>/dev/null

那么执行时长如何呢？取个平均一点的结果：

2972(us)

两者对比

可以看到，指针遍历的速度似乎比下标要快。但由于时差有些接近，也无法非常肯定，因此我们来看看编译生成的汇编。

#a.c生成的a.s
...
	movl	-4(%rbp), %eax
	cltq
	movb	$99, -1024016(%rbp,%rax)
	addl	$1, -4(%rbp)
.L2:
	movl	-4(%rbp), %eax
	cmpl	$1023999, %eax
...

#b.c生成的b.s
...
	movq	-8(%rbp), %rax
	movb	$99, (%rax)
	addq	$1, -8(%rbp)
.L2:
	movq	-8(%rbp), %rax
	cmpq	-16(%rbp), %rax
...

碍于篇幅，仅列出赋值循环中的部分的汇编代码。

可以看到，a.c（数组下标版本）生成的汇编中在给每个数组元素赋值时需要用数组首地址配合下标计算出要被赋值的单元位置。而b.c（指针版本）则不需要这一步运算。当然还有一个cltq指令的差异，该指令作用是将32位eax有符号扩展到64位。

到此，似乎汇编差异带来的性能差异符合我们刚才看到的时间度量差异。

但是，文章到此并未结束，细心的读者或许会注意到，我们刚才的编译是并未被优化的。那么下面，我们来试试编译优化的结果。

代码一的优化结果

$ gcc -o a a.c -O3
$ ./a 2>/dev/null
549(us)

代码二的优化结果

$ gcc -o b b.c -O3
$ ./b 2>/dev/null
546(us)

对比结果

首先，可以看到优化后的代码执行效率远高于优化前的。

其次，优化后，两段代码的执行时间似乎很相近。我们依旧来看看汇编代码：

#a.c经过O3优化的a.s
...
	leaq	32(%rsp), %rdi
	movl	$1024000, %edx
	movl	$99, %esi
	call	memset
	leaq	16(%rsp), %rdi
	xorl	%esi, %esi
...

#b.c经过O3优化的b.s
...
	leaq	32(%rsp), %rdi
	movl	$1024000, %edx
	movl	$99, %esi
	call	memset
	leaq	16(%rsp), %rdi
	xorl	%esi, %esi
...

你没看错，我也没有写错，经过优化后的代码，循环赋值部分是完全一样的。这也与我们的时间度量结果吻合。

总结

在无编译优化的情况下，数组下标的遍历方式会略慢于指针遍历，是由于数组下标方式在每次循环中需要利用数组首地址和数组下标计算出被使用的数组元素。

在O3优化情况下，编译优化带来的性能提升也是非常可观的，同时，编译优化也一定程度上缩小了遍历方式差异带来的性能差异。虽然O3优化有极个别时候会有指令乱序导致程序执行结果与预期不符的情况，但也是有相应解决方案的。

喜欢的朋友欢迎关注码哥，也可以在下方留言评论。

新年伊始，给大家拜年啦。

感谢观看！