This question already has an answer here:
-
With arrays, why is it the case that a[5] == 5[a]?
18 answers
-
Why does x[y] == y[x] in c++? [duplicate]
3 answers
As I have learned, one can write the following code:
char *a = new char[50];
for (int i = 0; i < 50; ++i) {
i[a] = '5';
}
It compiles. It works. It does exactly the same as
char *a = new char[50];
for (int i = 0; i < 50; ++i) {
a[i] = '5';
}
Is it just because:
a[b] is implemented as a macro *(a + b) by default and the fact that both code samples are valid is just an accident/compiler specific- it's standardized somewhere and the outcome of such algorithms should be the same on every platform
It is reasonable to assume that addition should be commutative, but if we implement operator[] in that way, we have made something else commutative, what might not be what we wanted.
The interesting fact is that there is no pointer[pointer] operator, so operator[] is not a macro.
I know it's bad. I know it's confusing the people who read the code. But I want to know if it's just an accident and it will not work in a distant land where unicorns have seven legs and horns are on their left cheek.
C++ standard, § 8.3.4, note 7 (page 185) (emphasis mine).
Except where it has been declared for a class (13.5.5), the subscript operator [] is interpreted in such a way that E1[E2] is identical to *((E1)+(E2)). Because of the conversion rules that apply to +, if E1 is an array and E2 an integer, then E1[E2] refers to the E2-th member of E1. Therefore, despite its asymmetric appearance, subscripting is a commutative operation.
Here is what C++11 standard has to say:
Note: Except where it has been declared for a class (13.5.5), the subscript operator [] is interpreted in such
a way that E1[E2] is identical to *((E1)+(E2)). Because of the conversion rules that apply to +, if E1 is an
array and E2 an integer, then E1[E2] refers to the E2-th member of E1. Therefore, despite its asymmetric
appearance, subscripting is a commutative operation. (emphasis is added).
So your assumption that a[b] is implemented as *(a + b) is correct, except that it is implemented directly in the compiler, not as a macro.
The expression E1[E2] is identical (by definition) to *((E1)+(E2))
...and then commutativity of index and pointer takes hold. See your friendly neighbourhood C++ standard, section 5.2.1 in this version: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3485.pdf
