Jak zauważa Joel w podcastie Stack Overflow # 34 , w C Programming Language (alias: K & R), wspomniano o tej właściwości tablic w C:a[5] == 5[a]

Joel mówi, że to z powodu arytmetyki wskaźników, ale wciąż nie rozumiem. Dlaczegoa[5] == 5[a] ?

Standard C definiuje []operatora w następujący sposób:

a[b] == *(a + b)

Dlatego a[5]oceni, aby:

*(a + 5)

i 5[a]oceni, aby:

*(5 + a)

ajest wskaźnikiem do pierwszego elementu tablicy. a[5]Jest to wartość, która znajduje się 5 elementów dalej od a, który jest taki sam jak *(a + 5)iz matematyki elementarnej szkoły wiemy te są równe (dodawanie jest przemienne ).

Ponieważ dostęp do tablicy jest zdefiniowany za pomocą wskaźników. a[i]jest zdefiniowany jako oznaczający *(a + i)przemienny.

Myślę, że inne odpowiedzi pomijają coś.

Tak, p[i]z definicji jest równoważne z tym *(p+i), co (ponieważ dodawanie jest przemienne) jest równoważne z *(i+p), co (ponownie, z definicji []operatora) jest równoważne i[p].

(A array[i]wewnątrz nazwa tablicy jest domyślnie konwertowana na wskaźnik do pierwszego elementu tablicy).

Ale zamienność dodawania nie jest w tym przypadku aż tak oczywista.

Gdy oba operandy są tego samego typu, a nawet różnych typów numerycznych, które są promowane do wspólnego typu, przemienność sens: x + y == y + x.

Ale w tym przypadku mówimy konkretnie o arytmetyce wskaźnika, gdzie jeden operand jest wskaźnikiem, a drugi liczbą całkowitą. (Liczba całkowita + liczba całkowita to inna operacja, a wskaźnik + wskaźnik to nonsens).

Opis +operatora w standardzie C ( N1570 6.5.6) mówi:

Ponadto oba operandy muszą mieć typ arytmetyczny lub jeden operand powinien być wskaźnikiem do pełnego typu obiektu, a drugi powinien być liczbą całkowitą.

Równie łatwo mógłby powiedzieć:

Ponadto oba operandy muszą mieć typ arytmetyczny lub lewy operand powinien być wskaźnikiem do pełnego typu obiektu, a prawy operand powinien być liczbą całkowitą.

w takim przypadku oba i + pi i[p]byłyby nielegalne.

W języku C ++ mamy naprawdę dwa zestawy przeciążonych +operatorów, które można luźno opisać jako:

pointer operator+(pointer p, integer i);

i

pointer operator+(integer i, pointer p);

z których tylko pierwszy jest naprawdę potrzebny.

Więc dlaczego tak jest?

C ++ odziedziczył tę definicję od C, która otrzymała ją od B (przemienność indeksowania tablic jest wyraźnie wspomniana w Odniesieniu użytkowników do B z 1972 r. ), Która otrzymała ją od BCPL (instrukcja z 1967 r.), Która mogła ją nawet otrzymać wcześniejsze języki (CPL? Algol?).

Pomysł, że indeksowanie tablic jest zdefiniowane w kategoriach dodawania i że dodawanie, nawet wskaźnika i liczby całkowitej, jest przemienne, sięga wielu dziesięcioleci do języków przodków C.

Języki te były znacznie rzadziej pisane niż współczesne C. W szczególności rozróżnianie wskaźników i liczb całkowitych było często ignorowane. (Wcześniejsi programiści C czasami używali wskaźników jako liczb całkowitych bez znaku, zanim unsignedsłowo kluczowe zostało dodane do języka). Więc pomysł, aby dodanie było nieprzemienne, ponieważ operandy różnych typów prawdopodobnie nie przyszedłby do projektantów tych języków. Jeśli użytkownik chciał dodać dwie „rzeczy”, bez względu na to, czy są to liczby całkowite, wskaźniki lub coś innego, język nie był w stanie temu zapobiec.

Z biegiem lat każda zmiana tej reguły złamałaby istniejący kod (chociaż norma ANSI C z 1989 roku mogła być dobrą okazją).

Zmiana C i / lub C ++ w taki sposób, aby wymagała umieszczenia wskaźnika po lewej stronie i liczby całkowitej po prawej stronie, może zepsuć istniejący kod, ale nie nastąpiłaby utrata prawdziwej mocy ekspresyjnej.

Mamy więc teraz arr[3]i 3[arr]dokładnie to samo, chociaż ta ostatnia forma nigdy nie powinna pojawić się poza IOCCC .

I oczywiście

 ("ABCD"[2] == 2["ABCD"]) && (2["ABCD"] == 'C') && ("ABCD"[2] == 'C')

Głównym tego powodem było to, że w latach 70., kiedy projektowano C, komputery nie miały dużo pamięci (64 KB było dużo), więc kompilator C nie sprawdzał dużo składni. Dlatego „ X[Y]” zostało raczej ślepo przetłumaczone na „ *(X+Y)”

To wyjaśnia także składnie „ +=” i „ ++”. Wszystko w formie „ A = B + C” miało tę samą skompilowaną formę. Ale jeśli B był tym samym obiektem co A, dostępna była optymalizacja na poziomie zespołu. Ale kompilator nie był wystarczająco jasny, aby go rozpoznać, więc programista musiał ( A += C). Podobnie, jeśli Ctak 1, dostępna była inna optymalizacja na poziomie zespołu, a programista musiał to wyraźnie wyrazić, ponieważ kompilator jej nie rozpoznał. (Ostatnio robią to kompilatory, więc te składnie są obecnie w dużej mierze niepotrzebne)

Jedna rzecz, o której nikt nie wspominał o problemie Diny z sizeof:

Możesz dodać tylko liczbę całkowitą do wskaźnika, nie możesz dodać dwóch wskaźników razem. W ten sposób, dodając wskaźnik do liczby całkowitej lub liczbę całkowitą do wskaźnika, kompilator zawsze wie, który bit ma rozmiar, który należy wziąć pod uwagę.

Aby dosłownie odpowiedzieć na pytanie. Nie zawsze tak jestx == x

double zero = 0.0;
double a[] = { 0,0,0,0,0, zero/zero}; // NaN
cout << (a[5] == 5[a] ? "true" : "false") << endl;

odciski

false

Właśnie odkryłem, że ta brzydka składnia może być „przydatna”, a przynajmniej bardzo przyjemna do zabawy, gdy chcesz poradzić sobie z tablicą indeksów odnoszących się do pozycji w tej samej tablicy. Może zastąpić zagnieżdżone nawiasy kwadratowe i uczynić kod bardziej czytelnym!

int a[] = { 2 , 3 , 3 , 2 , 4 };
int s = sizeof a / sizeof *a;  //  s == 5

for(int i = 0 ; i < s ; ++i) {  

           cout << a[a[a[i]]] << endl;
           // ... is equivalent to ... 
           cout << i[a][a][a] << endl;  // but I prefer this one, it's easier to increase the level of indirection (without loop)

}

Oczywiście jestem całkiem pewien, że nie ma takiego przypadku w prawdziwym kodzie, ale i tak mnie to zainteresowało :)

Ładne pytanie / odpowiedź.

Chcę tylko zaznaczyć, że wskaźniki C i tablice nie są takie same , chociaż w tym przypadku różnica nie jest istotna.

Rozważ następujące deklaracje:

int a[10];
int* p = a;

W a.out, symbol aznajduje się pod adresem, który jest początkiem tablicy, a symbol pznajduje się pod adresem, w którym przechowywany jest wskaźnik, a wartość wskaźnika w tym miejscu pamięci jest początkiem tablicy.

Dla wskaźników w C mamy

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

i również

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

Dlatego prawdą jest, że a[5] == 5[a].

Nie odpowiedź, ale tylko trochę do myślenia. Jeśli klasa ma przeciążonego operatora indeksu / indeksu dolnego, wyrażenie 0[x]nie będzie działać:

class Sub
{
public:
    int operator [](size_t nIndex)
    {
        return 0;
    }   
};

int main()
{
    Sub s;
    s[0];
    0[s]; // ERROR 
}

Ponieważ nie mamy dostępu do klasy int , nie można tego zrobić:

class int
{
   int operator[](const Sub&);
};

Ma bardzo dobre wytłumaczenie w TUTORIAL NA WSKAŹNIKI I SZABLONY W C autorstwa Teda Jensena.

Ted Jensen wyjaśnił to jako:

W rzeczywistości jest to prawdą, tzn. Gdziekolwiek pisze się a[i], można go zastąpić *(a + i) bez żadnych problemów. W rzeczywistości kompilator utworzy ten sam kod w obu przypadkach. Widzimy zatem, że arytmetyka wskaźników jest tym samym, co indeksowanie tablic. Każda ze składni daje ten sam wynik.

To nie znaczy, że wskaźniki i tablice są tym samym, nie są. Mówimy tylko, że aby zidentyfikować dany element tablicy, mamy do wyboru dwie składnie, jedną z wykorzystaniem indeksowania tablic i drugą z wykorzystaniem arytmetyki wskaźników, które dają identyczne wyniki.

Teraz, patrząc na to ostatnie wyrażenie, jego część .. (a + i), jest prostym dodatkiem używającym operatora + i reguł C mówi, że takie wyrażenie jest przemienne. To znaczy (a + i) jest identyczne z (i + a). W ten sposób moglibyśmy pisać *(i + a)równie łatwo jak *(a + i). Ale *(i + a)mógł pochodzić i[a]! Z tego wszystkiego pochodzi ciekawa prawda, że ​​jeśli:

char a[20];

pisanie

a[3] = 'x';

to to samo co pisanie

3[a] = 'x';

Wiem, że odpowiedź na to pytanie, ale nie mogłam się powstrzymać przed udostępnieniem tego wyjaśnienia.

Pamiętam Zasady projektowania kompilatora, Załóżmy, że ajest to inttablica o rozmiarze int2 bajtów, a adres podstawowy ato 1000.

Jak a[5]będzie działać ->

Base Address of your Array a + (5*size of(data type for array a))
i.e. 1000 + (5*2) = 1010

Więc,

Podobnie, gdy kod c zostanie podzielony na kod 3-adresowy, 5[a]stanie się ->

Base Address of your Array a + (size of(data type for array a)*5)
i.e. 1000 + (2*5) = 1010 

Więc w zasadzie oba stwierdzenia są skierowane do tej samej lokalizacji w pamięci, a więc a[5] = 5[a].

To wyjaśnienie jest również powodem, dla którego ujemne indeksy w tablicach działają w C.

tzn. jeśli uzyskam dostęp a[-5], da mi to

Base Address of your Array a + (-5 * size of(data type for array a))
i.e. 1000 + (-5*2) = 990

Zwróci mi obiekt w lokalizacji 990.

W macierzy C , arr[3]i 3[arr]są takie same, a ich odpowiadające oznaczenia wskaźnika są *(arr + 3)na *(3 + arr). Ale wręcz przeciwnie [arr]3lub [3]arrjest niepoprawny i spowoduje błąd składniowy, ponieważ (arr + 3)*i (3 + arr)*nie są prawidłowymi wyrażeniami. Powodem jest to, że operator dereferencji powinien być umieszczony przed adresem podanym w wyrażeniu, a nie po adresie.

w kompilatorze c

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

istnieją różne sposoby odwoływania się do elementu w tablicy! (NIE WSZYSTKO WEIRD)

Trochę historii. Wśród innych języków BCPL miał dość duży wpływ na wczesny rozwój C. Jeśli zadeklarowałeś tablicę w BCPL za pomocą czegoś takiego:

let V = vec 10

który faktycznie przydzielił 11 słów pamięci, a nie 10. Zwykle V był pierwszy i zawierał adres następnego słowa. Tak więc, w przeciwieństwie do C, nazewnictwo V poszło w to miejsce i odebrało adres elementu zeroeth tablicy. Zatem pośrednia macierz w BCPL, wyrażona jako

let J = V!5

naprawdę musiałem to zrobić J = !(V + 5)(używając składni BCPL), ponieważ konieczne było pobranie V, aby uzyskać adres bazowy tablicy. Zatem V!5i 5!Vbyły synonimami. Jako niepotwierdzone spostrzeżenie, WAFL (Warwick Functional Language) został napisany w BCPL i, zgodnie z moją najlepszą pamięcią, miałem tendencję do używania tej drugiej składni zamiast pierwszej do uzyskiwania dostępu do węzłów używanych do przechowywania danych. Przyznaję, że pochodzi to gdzieś pomiędzy 35 a 40 lat temu, więc moja pamięć jest trochę zardzewiała. :)

Innowacja rezygnacji z dodatkowego słowa pamięci i kompilatora wstawiającego adres bazowy tablicy, gdy została ona nazwana, pojawiła się później. Według artykułu z historii C zdarzyło się to mniej więcej w czasie, gdy struktury zostały dodane do C.

Zauważ, że !w BCPL był zarówno operatorem jednoargumentowym, jak i operatorem binarnym, w obu przypadkach działając pośrednio. tylko, że postać binarna zawierała dodanie dwóch operandów przed wykonaniem pośrednictwa. Biorąc pod uwagę zorientowaną na słowa naturę BCPL (i B), miało to naprawdę sens. Ograniczenie „wskaźnika i liczby całkowitej” stało się konieczne w C, gdy zyskało typy danych i sizeofstało się rzeczą.

Cóż, ta funkcja jest możliwa tylko ze względu na obsługę języka.

Kompilator interpretuje a[i]jako *(a+i)i wyrażenie 5[a]ocenia na *(5+a). Ponieważ dodawanie jest przemienne, okazuje się, że oba są równe. Stąd wyrażenie ocenia na true.

W C.

 int a[]={10,20,30,40,50};
 int *p=a;
 printf("%d\n",*p++);//output will be 10
 printf("%d\n",*a++);//will give an error

Wskaźnik jest „zmienną”

nazwa tablicy to „mnemoniczny” lub „synonim”

p++;jest prawidłowy, ale a++jest nieprawidłowy

a[2] jest równe 2 [a], ponieważ wewnętrzna operacja na obu z nich to

„Arytmetyka wskaźnika” obliczona wewnętrznie jako

*(a+3) równa się *(3+a)

typy wskaźników

1) wskaźnik do danych

int *ptr;

2) const wskaźnik do danych

int const *ptr;

3) const wskaźnik do const danych

int const *const ptr;

a tablice są typu (2) z naszej listy
Kiedy definiujesz tablicę jednocześnie, jeden adres jest inicjowany w tym wskaźniku
Ponieważ wiemy, że nie możemy zmienić ani zmodyfikować stałej wartości w naszym programie, ponieważ powoduje to błąd przy kompilacji czas

The Główną różnicą znalazłem to ...

Możemy ponownie zainicjować wskaźnik za pomocą adresu, ale nie w tym samym przypadku z tablicą.

======
i wracając do pytania ...
a[5]to nic, ale *(a + 5)
można to łatwo zrozumieć
a - zawierając adres (ludzie nazywają go jako adres bazowy) tak jak (2) typ wskaźnika na naszej liście
[] - tym operatorem może być wymienny ze wskaźnikiem *.

więc w końcu ...

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