Is it still true that using pointers is significantly faster than using the array syntax in C?

Question

With current C compilers, is it still true that using the array syntax (a[i]) is slower than using pointers (*(p+i))?

Answer 1

They are exactly equivalent. Array access is syntactic sugar for pointer math.

Answer 2

No, according to the C and C++ standards a[i] is by definition equivalent to *(a+i). this also implies that a[1] is equivalent to 1[a]. Try it :)

Answer 3

They should be the same. But:

for( i = 0; i < ...; ++ i ) ... array[i] ...

could be slower than:

for( p = array; *p; ++ p ) ... *p ...

because in the former case compiler could need to do *(array+i), while in the second you just do (*p).

In trivial cases, however, compiler should be able to optimize and generate the same machine code.

Answer 4

Hell No! a[i] is always equivalent to *(a+i).

a[i] = *(a + i) = *(i + a) =i[a];

Answer 5

On x86 or x86_64, using p[i] or *(p+i) (note: these two forms are identical in the C language) may be faster than incrementing p at each step of the loop, assuming you need to keep i around for some other purpose already. The x86 architecture has efficient addressing for base/offset usage like this, including scaling the offset by small powers of 2.

On the other hand, if you can eliminate i by incrementing p, you may reduce the number of registers needed in you loop, which could allow further optimization. Here are some quick thoughts on the relative cost in various cases on x86:

• If you array a has static storage duration (static or extern global) in non-PIC-compiled code, the a[i] and *p (with no i) methods use the same number of registers (e.g. 0xdeadbeef(,%ecx,4) vs (%esi)).
• If Your array a is automatic (local stack variable) and not a variable-length array, the a[i] and *p methods use the same number of registers (e.g. 12(%esp,%ecx,4) vs (%esi) where %esp, the stack pointer, is already reserved anyway).
• If your array a has static storage duration and your code is compiled as PIC, a[i] is probably significantly more expensive than the *p method, even if you have to keep i around for another purpose anyway.
• If your array a is not an array variable in the current scope, but a pointer to an array passed to your function from somewhere else, then a[i] takes one more register than *p (e.g. (%eax,%ecx,4) vs (%esi)).

Answer 6

There may be some circumstances where something like

while (*s++ = *d++)
   ;

might be faster than

while (s[i] = d[i])
   i++;

but even that will probably be optimized away by good compilers.

Answer 7

The compiler will translate them to pointer code anyway, it just makes it easier to use them.

Think of array operator as an inline function for the pointer equivalent.

Answer 8

They are equivalent. But algorithms that use the array syntax are typically written

int a[];
for (int n = 0; n < size; n++) { ... Do stuff with a[n]; }

which needs one more addition for each access to an element of a than

int a[size];
int *end = a + size;
for (int *i = a; i != end; ++i) { ... Do the same stuff with *i ; }

Some compilers might optimize the first version into the second though.

Answer 9

It's obvious that's not what he means, this should help.

// which is faster? *t or t[i]?
process_some_array(T *t, size_t n)
{
    T *end = &t[n];
    for (T *t = t; t < end; ++t)
        // do stuff with *t
    for (size_t i = 0; i < n; ++i)
        // do stuff with t[i]
}

The answer is not as long as your compiler has no optimization whatsoever. For the general case you should not worry about the difference, as it is miniscule if present at all. Furthermore it's generally easier for yourself, and your fellows to parse and debug.

If this is not what you meant, I'm afraid it's a stupid question, see one of the other answers.

Answer 10

Pointer and Array both are accessing through address.Array is behave like a constant pointer and pointer used to hold the address of any value.So same thing is both access the value through address. On account of that both are exactly equivalent.