This doesn't look like a function. What is this?

Question

A friend asked me to write a function in C to return the 100th element of an array. I\'m not very familiar with C, so I wasn\'t sure how to make a generic function that coul

Answer 1

When using pointers, pointer[ index ] and index[ pointer ] are actually the same. It's not a function, its a regular operator; its the same as array[ GetHundredthElement ] or array[ 100 - 1 ].

Answer 2

In C, the bracket notation is short hand for pointer arithmetic. A normal use like x[i] is syntactically equivalent to *(x + i) (remember that arrays are pointers). If instead you had used i[x] then it's the same as *(i + x) and produces the same output. As noted by other answers, this approach is not a function, just an interesting technique.

Answer 3

You are right about the fact that GetHundredthElement is not a function-- it is, as you would expect, an integer.

However, this illustrates a surprising ability in C where you can reverse the order of your array access!

assert(a[5] == 5[a]);

This is because an array access can be implemented in pointer arithmetic:

assert(a[5] == *(a+5));
assert(*(a+5) == *(5+a));
assert(*(5+a) == 5[a]);

Answer 4

This is the special funky way you can access arrays.

Let's recall that arrays can be treated like pointers, and you can use arithmetic.

For example:

let x be some arbitrary array:

int x[4];

Implies accessing x's 5th element, which is *(x+4).

Terrible example of memory layout:

x -> [0][1][2][3][4]

Now, the weird thing you can do with C arrays/pointers to blocks, is flip the number and variable in bracket notation.

x[4] is equal to 4[x]

Because they break down to:

*(x+4) and *(4+x)

Answer 5

It's not a function, it simply takes advantage of a little-known C fact that array indexes can be interchanged. All the x[y] notation really means is that you're accessing the xth offset of the y array. But you could just as easily write y[x] in your case and get the same result.

99[array] and array[99] are interchangeable and mean the same thing. By declaring GetHundredthElement to be 99, your friend played a neat trick :)

You CAN however write a generic function to get the hundredth element of an array fairly easily using C++ templates (not C).