什么使指针比数组更快?

时间:2011-08-31 17:35:09

标签: c

我正在使用Google搜索,并为指针找到了以下语法

  void main()
 {
  char a[10]="helloworld";
  char *p=a;
  printf("%c",p[0]);
 }

我不知道Pointers也可以以数组形式访问。我曾经使用*进行指针操作 我使用[0]表示数组,* p表示指针操作,这就是为什么我不知道其他两件事。 从上面可以看出,我们可以通过以下任何一种方式访问​​数组的第二个元素

  printf("%C",a[1]);   \\ this is the array
  printf("%c",*(a+1));  \\ this is the array using *
  printf("%c", p[1]);     \\ using the pointer 
  printf("%C",*(p+1));    \\ using the pointer

现在我想知道:哪个操作更快?我读到使用指针的操作更快,这就是为什么C保持在顶部以便快速执行并且没有其他语言能够超越其坚固性。

现在真正的问题:是什么让指针操作更快?

1)*(p + 0)*(地址的值)制作技巧或

2)p [0]

因为我们使用

 *(a+1) or *(p+1) both are same 
  a[1] or p[1] both are same 

当正常数组可以用作*(a + 1)(在地址使用*值)时,就像指针一样。为什么我们使用指针来加快操作?当两者具有相同的语法时,正常数组和指针在这些语法中使用*时为什么指针更快?

但伙计们请告诉我为什么我们使用指针?我的教授告诉我指针更快,因为它们指向地址而不是应该在该位置搜索变量。

6 个答案:

答案 0 :(得分:10)

我实际上不希望*(ptr + offset)ptr[offset]更快。事实上,在我的机器上,以下函数被编译成完全相同的汇编代码:

int
ArrayRef(int* array, int index)
{
    return array[index];
}

int
PointerRef(int* array, int index)
{
    return *(array + index);
}

(清理)看起来像:

ArrayRef:
    pushq   %rbp
    movq    %rsp, %rbp
    movq    %rdi, -8(%rbp)
    movl    %esi, -12(%rbp)
    movl    -12(%rbp), %eax
    cltq
    salq    $2, %rax
    addq    -8(%rbp), %rax
    movl    (%rax), %eax
    leave
    ret

PointerRef:
    pushq   %rbp
    movq    %rsp, %rbp
    movq    %rdi, -8(%rbp)
    movl    %esi, -12(%rbp)
    movl    -12(%rbp), %eax
    cltq
    salq    $2, %rax
    addq    -8(%rbp), %rax
    movl    (%rax), %eax
    leave
    ret

(gcc 4.5.0,x86_64,没有优化)。或者使用-O3

ArrayRef:
    movslq  %esi, %rsi
    movl    (%rdi,%rsi,4), %eax
    ret

PointerRef:
    movslq  %esi, %rsi
    movl    (%rdi,%rsi,4), %eax
    ret

答案 1 :(得分:3)

如果数组在本地堆栈作用域或静态存储器中分配,则数组访问速度更快,因为它可以通过EBP寄存器中的值的偏移量或通过固定地址的直接偏移量直接访问,而不是试图访问堆栈变量中的指针值,然后添加到该变量的值并解除引用。

例如,如果你写的数组如下:

int main()
{
    int array[5] = {1, 2, 3, 4, 5};
    //... more code

    return 0;
}

为了访问array[3]处的值,编译器只会发出一个简单的命令,例如(适用于x86):

MOV -8(%ebp), %eax

这是因为如果我们查看堆栈,我们会看到以下内容:

EBP + 4 : Return Address
EBP     : Previous function's stack activation record
EBP - 4 : array[4]
EBP - 8 : array[3]
EBP - 12: array[2]
EBP - 16: array[1]
EBP - 20: array[0]

因此,为了访问array[3]处的值,只需要一条指令。那很快。

答案 2 :(得分:1)

在您提供的示例中,p[1]的速度不会快于a[1]

答案 3 :(得分:0)

数组名称本质上是指向该数组第一个元素的指针 - 因此,它们应该完全相同。

静态创建的数组有自己的类型,它包含了编译时定义的大小,这使得它们在技术上与指针不同,但是出于所有密集的目的,示例中的数组名称和字符指针可以相同地使用。

答案 4 :(得分:0)

数组指针, p a 之后没有区别

char a[10]="helloworld";
char *p=a;

a p 都是指向char的指针,它们指向同一个地方 - 数组在内存中的开头

使用“operator []”也等同于指针算术

a[i] 

将被替换为

*(a+i)

这意味着指向数组开头的指针将被i * sizeof(char)移动到数组的第i个元素的位置。

当您尝试遍历所有元素时,会出现真正的时间差异,例如,复制字符串:

char a[10] = "helloworld";
char b[10];
for (int i = 0; i < 10; ++i) b[i] = a[i]; // using array element accessing method
对于循环的每次迭代,

将产生类似b + i(又名为b by i * sizeof(char))和a + i(也称为i * sizeof(char)的移位)的算术,并且

char a[10] = "helloworld";
char b[10];
char *_a, *_b;
for (_a = a, _b = b; *_a != '\0'; ++_a, ++_b) *_a = *_b; // using pointers arithmetic method
*b = '\0';

从这些计算中解脱出来,每次只按char的大小移动两个指针。

答案 5 :(得分:-1)

指针比数组更快来自以下示例。

假设您要实现strcpy函数,即将一个以空字符结尾的字符串复制到另一个字符串。我们来看两个例子:

第一个:

char* strcpy(char* dest, const char* src)
{
    int i = 0;
    while( src[i] != '\0' ) {
        dest[i] = src[i];
        i++;
    }
    dest[i] = '\0';

    return dest;
}

第二个:

char* strcpy(char* dest, const char* src)
{
    char *save = dest;
    while( *src != '\0' )
    {
        *dest++ = *src++;
    }
    *dest = '\0';

     return save;
}

第二个示例更有效地实现,因为它在每次迭代中执行的内存修改更少,并且它使用指针而不是数组。但有两件事:

  1. 它不是快速的指针,它是使用它们进行优化的算法。
  2. 优化程序可以轻松自动执行此类优化,因此您最终可能会使用相同的生成代码。