Some time ago friend of mine asked me how to operate on array without subscript operator, and – to be honest – I supposed it’ll took less than few hours…
NOTE as for all pointer arithmetic it’s rather inadvisable to use this trick in ‘common life projects’.
But I have some more knowledge so I’m sharing! (:
And if you want something more about pointer arithmetic you can check my previous article.
If you want to operate on table without using subscript operator you need to use this little instruction:
* ( (e2) + (e1) )
It’ll work as long as one of arguments is pointer to table and second is integer value (within array range).
So if we, for example, have array tmp with five elements and we want to fill it with numbers from 1 do 5 we can write:
for(int i=0; i<5; ++i) *(tmp+i) = i+1;
And for multidimensional array answer is: It depends.
In my friend's case instead of:
I could use:
* ( (j) + *( (i) + (tmp)) )
But it's valid only for array of pointers to arrays (eg. int ** pointers where we first point it to int* and then create new int in a loop), if you curious what you should use for 'conventional' twodimensional arrays check .
Wait, but Why?
Lets assume we have arr array.
As we all (probably) know the name of array is pointer to first element of that array, and contains address in memory where we can find it. By definition arr is &arr. If we add 1 to arr in result we'll get address to next element of array, so:
arr+i == &arr[i]
And then we have tmp[ROWS][COLS] array. All we need to know is:
tmp[i] == &tmp[i]
so if we add 1 to tmp[i] we'll get address of tmp[i]. As we already know
tmp[i] == *(arr+i)
tmp[i][j] => *(tmp[i] + j) => *( *(tmp+i) +j )
Note: I found that for "conventional" arr[sizeX][sizeY] 2D arrays with int (*ptr)[sizeX] type formula for calculating cell address goes like that:
addr( arr) + (sizeof(type) * COLS * row + sizeof(type)*col);
Although I can't force it to work with my compiler with real 2D array (not 1D array like arr[sizeX * sizeY]);