Thread: Pointers+arrays

it's called pointer arithmetic, but:

int *ptr_x;

it's perfectly acceptable to do traversals like that.

You'd want to use pointers in inner loops of often-called code, for example.

Only if you have proved your point with profiler.
Otherwise you want everywhere to use code that is simplier to read

Unless you are JUST doing a loop for the purpose of walking through an array without actually doing anything with the array, I would say that there is no measurable difference between the two - if the array is huge, cache-misses will be more noticably than the addition of a pointer and the index. On x86 it is essentially just a more complex addressing mode to get there, which won't affect the time the processor takes to get there, only the size of the code will be different.

Of course, any modern compiler will understand these type of references, and optimize it.

There are situations where a pointer is more efficient, but for most purposes, if the code is easy to read, that is more important.

--
Mats

You have to show the assembly result of the compilation with the optimization turned on to prove your statement...

Otherwise its just a guess... And I belive - you guessed wrong.

Pointer is better than Array , i hv a example

I compared the assembly output of the MinGW port of g++ 3.4.2 with these two sample programs:

Code:

// Sample Program A
int main()
{
    int x[10] = {0};
    int ans = x[4] + x[5];
}

Code:

// Sample Program B
int main()
{
    int x[10] = {0};
    int *ptr = &x[4];
    int ans = *ptr + *(ptr+1);
}

Lo and behold, their assembly output with the -O1 optimisation flag was the same... and again for the -O2 flag!

(I only checked with -O1 and -O2.)

Originally Posted by obaid

Pointer is better than Array , i hv a example

A array example:-

Code:

int  x[10];
int ans = x[4] + x[5];

Compiler may do something like this:

Code:

    lea  ebx, x
    mov eax, [ebx + 4 *4]
    add eax, [ebx + 5 * 4]
    mov ans, eax

Note that those 4 * 4 and 5 * 4 are constants that the compiler will calculate during compilation.

if we see in low level...... than we known that, there is a lots of step before adding these two value , first step to calculate the address of x[4] and How its calculate, look , first of all x array hv only hold its first element's address , and formulae of calculate addressing is { x's address + (type size)*(index no) } .

in array example , complier calculate more .

A Pointer Example:-

Code:

int x[10];
int *ptr = &x[4];
int ans = *ptr + *(ptr+1);

Code:

   lea  ebx, x
   lea  ebx, [ebx + 4 *4]
   mov eax, [ebx]
   add eax, [ebx+1 * 4]
   mov eax, ans

I don't really see how this is more efficient. Did you have a different processor architecture in mind?

in this example complier calcute the address only one time, b/c ptr already hv the address of 4th index and if we add in address the we hv 5th index.

thats why pointer is better then array.

If the compiler can figure out how to convert array indexes into pointer references, then it can do that for both of the above cases, so there's really no difference. I have not seen a compiler that does badly at this sort of things for the last several years, at least not GCC or Microsoft versions. If you use a different compiler, then I suggest you take a look at the code the compiler generates, and if there's really different results, then you probably want to look at what other compilers you can use.

--
Mats

its not a assembly language problem , its a memory adressing management problem which hv to face the complier. okz

If you are trying to say that accessing by pointers is better than accessing by array indices because the compiler has to do more work in optimisation for the latter, then I think you are programming in the wrong language for your taste.

If not, how can your example possibly be valid when even at machine level both programs do exactly the same thing?