Wie Joel im Stack Overflow-Podcast Nr. 34 in der Programmiersprache C (auch bekannt als: K & R) hervorhebt, wird diese Eigenschaft von Arrays in C:a[5] == 5[a]

Joel sagt, dass es an der Zeigerarithmetik liegt, aber ich verstehe es immer noch nicht. Waruma[5] == 5[a] ?

Der C-Standard definiert den []Operator wie folgt:

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

Daher a[5]wird bewertet, um:

*(a + 5)

und 5[a]wird bewerten zu:

*(5 + a)

aist ein Zeiger auf das erste Element des Arrays. a[5]ist der Wert, der 5 Elemente weiter entfernt ist a, was derselbe ist *(a + 5), und aus der Grundschulmathematik wissen wir, dass diese gleich sind (Addition ist kommutativ ).

Weil der Array-Zugriff in Form von Zeigern definiert wird. a[i]ist definiert als gemeint *(a + i), was kommutativ ist.

Ich denke, bei den anderen Antworten wird etwas übersehen.

Ja, p[i]ist per Definition äquivalent zu *(p+i), was (weil Addition kommutativ ist) äquivalent zu ist *(i+p), was (wiederum nach der Definition des []Operators) äquivalent zu ist i[p].

(Und in array[i]wird der Arrayname implizit in einen Zeiger auf das erste Element des Arrays konvertiert.)

Aber die Kommutativität der Addition ist in diesem Fall nicht allzu offensichtlich.

Wenn beide Operanden vom gleichen Typ sind oder sogar von unterschiedlichen numerischen Typen, die zu einem gemeinsamen Typ heraufgestuft werden, ist Kommutativität durchaus sinnvoll : x + y == y + x.

In diesem Fall handelt es sich jedoch speziell um eine Zeigerarithmetik, bei der ein Operand ein Zeiger und der andere eine Ganzzahl ist. (Ganzzahl + Ganzzahl ist eine andere Operation, und Zeiger + Zeiger ist Unsinn.)

In der Beschreibung des +Bedieners nach C-Standard ( N1570 6.5.6) heißt es:

Außerdem müssen entweder beide Operanden einen arithmetischen Typ haben, oder ein Operand muss ein Zeiger auf einen vollständigen Objekttyp sein, und der andere muss einen ganzzahligen Typ haben.

Es hätte genauso gut sagen können:

Außerdem müssen entweder beide Operanden einen arithmetischen Typ haben, oder der linke Operand muss ein Zeiger auf einen vollständigen Objekttyp sein, und der rechte Operand muss einen ganzzahligen Typ haben.

in diesem Fall beides i + pund i[p]wäre illegal.

In C ++ - Begriffen haben wir wirklich zwei Sätze überladener +Operatoren, die lose beschrieben werden können als:

pointer operator+(pointer p, integer i);

und

pointer operator+(integer i, pointer p);

davon ist nur der erste wirklich notwendig.

Warum ist es so?

C ++ hat diese Definition von C geerbt, das sie von B erhalten hat (die Kommutativität der Array-Indizierung wird in der Benutzerreferenz von 1972 zu B ausdrücklich erwähnt ), die sie von BCPL (Handbuch vom 1967) erhalten hat, was sie möglicherweise sogar erhalten hat frühere Sprachen (CPL? Algol?).

Die Idee, dass die Array-Indizierung als Addition definiert wird und dass die Addition selbst eines Zeigers und einer Ganzzahl kommutativ ist, geht viele Jahrzehnte auf die Ahnensprachen von C zurück.

Diese Sprachen waren viel weniger stark typisiert als das moderne C. Insbesondere wurde die Unterscheidung zwischen Zeigern und ganzen Zahlen oft ignoriert. (Frühe C-Programmierer verwendeten manchmal Zeiger als vorzeichenlose Ganzzahlen, bevor das unsignedSchlüsselwort zur Sprache hinzugefügt wurde.) Die Idee, das Hinzufügen nicht kommutativ zu machen, weil die Operanden unterschiedlichen Typs sind, wäre den Designern dieser Sprachen wahrscheinlich nicht in den Sinn gekommen. Wenn ein Benutzer zwei "Dinge" hinzufügen wollte, unabhängig davon, ob es sich bei diesen "Dingen" um Ganzzahlen, Zeiger oder etwas anderes handelt, lag es nicht an der Sprache, dies zu verhindern.

Und im Laufe der Jahre hätte jede Änderung dieser Regel den bestehenden Code gebrochen (obwohl der ANSI C-Standard von 1989 eine gute Gelegenheit gewesen sein könnte).

Wenn Sie C und / oder C ++ so ändern, dass der Zeiger links und die Ganzzahl rechts gesetzt werden müssen, wird möglicherweise vorhandener Code beschädigt, es kommt jedoch nicht zu einem Verlust der tatsächlichen Ausdruckskraft.

Jetzt haben arr[3]und 3[arr]meinen wir genau dasselbe, obwohl die letztere Form niemals außerhalb des IOCCC erscheinen sollte .

Und natürlich

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

Der Hauptgrund dafür war, dass Computer in den 70er Jahren, als C entwickelt wurde, nicht viel Speicher hatten (64 KB waren viel), so dass der C-Compiler nicht viel Syntaxprüfung durchführte. Daher wurde " X[Y]" ziemlich blind in " *(X+Y)" übersetzt.

Dies erklärt auch die Syntax " +=" und " ++". Alles in der Form " A = B + C" hatte die gleiche kompilierte Form. Wenn B jedoch dasselbe Objekt wie A war, war eine Optimierung auf Baugruppenebene verfügbar. Aber der Compiler war nicht hell genug, um es zu erkennen, also musste der Entwickler ( A += C). In ähnlicher Weise Cwar 1eine andere Optimierung auf Assembly-Ebene verfügbar, und der Entwickler musste sie erneut explizit angeben, da der Compiler sie nicht erkannte. (In jüngerer Zeit tun dies Compiler, daher sind diese Syntaxen heutzutage weitgehend unnötig.)

Eine Sache, die niemand über Dinahs Problem erwähnt zu haben scheint sizeof:

Sie können einem Zeiger nur eine Ganzzahl hinzufügen, Sie können nicht zwei Zeiger zusammenfügen. Auf diese Weise weiß der Compiler beim Hinzufügen eines Zeigers zu einer Ganzzahl oder einer Ganzzahl zu einem Zeiger immer, welches Bit eine Größe hat, die berücksichtigt werden muss.

Die Frage wörtlich beantworten. Das stimmt nicht immerx == x

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

druckt

false

Ich finde nur heraus, dass diese hässliche Syntax "nützlich" sein kann oder zumindest sehr viel Spaß macht, wenn Sie sich mit einem Array von Indizes befassen möchten, die sich auf Positionen in demselben Array beziehen. Es kann verschachtelte eckige Klammern ersetzen und den Code lesbarer machen!

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)

}

Natürlich bin ich mir ziemlich sicher, dass es dafür keinen Anwendungsfall in echtem Code gibt, aber ich fand es trotzdem interessant :)

Schöne Frage / Antwort.

Ich möchte nur darauf hinweisen, dass C-Zeiger und Arrays nicht gleich sind , obwohl in diesem Fall der Unterschied nicht wesentlich ist.

Beachten Sie die folgenden Erklärungen:

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

In a.outbefindet sich das Symbol aan einer Adresse, die der Anfang des Arrays ist, und das Symbol pbefindet sich an einer Adresse, an der ein Zeiger gespeichert ist, und der Wert des Zeigers an dieser Speicherstelle ist der Anfang des Arrays.

Für Zeiger in C haben wir

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

und auch

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

Daher ist es wahr, dass a[5] == 5[a].

Keine Antwort, sondern nur ein Denkanstoß. Wenn die Klasse einen überladenen Index- / Indexoperator hat, 0[x]funktioniert der Ausdruck nicht:

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

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

Da wir keinen Zugriff auf die Klasse int haben , ist dies nicht möglich:

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

Es hat eine sehr gute Erklärung in A TUTORIAL ON POINTERS AND ARRAYS IN C. von Ted Jensen.

Ted Jensen erklärte es als:

In der Tat ist dies wahr, dh wo immer man schreibt a[i], kann es durch ersetzt werden*(a + i) ohne Probleme durch ersetzt werden. Tatsächlich erstellt der Compiler in beiden Fällen denselben Code. Wir sehen also, dass Zeigerarithmetik dasselbe ist wie Array-Indizierung. Jede Syntax führt zum gleichen Ergebnis.

Dies bedeutet NICHT, dass Zeiger und Arrays dasselbe sind, sie sind es nicht. Wir sagen nur, dass wir zur Identifizierung eines bestimmten Elements eines Arrays die Wahl zwischen zwei Syntaxen haben, eine mit Array-Indizierung und die andere mit Zeigerarithmetik, die identische Ergebnisse liefern.

Das Betrachten dieses letzten Ausdrucks, ein Teil davon (a + i), ist eine einfache Ergänzung unter Verwendung des Operators +, und die Regeln von C besagen, dass ein solcher Ausdruck kommutativ ist. Das heißt (a + i) ist identisch mit (i + a). So konnten wir *(i + a)genauso einfach schreiben wie *(a + i). Hätte *(i + a)aber kommen können i[a]! Aus all dem ergibt sich die merkwürdige Wahrheit, dass wenn:

char a[20];

Schreiben

a[3] = 'x';

ist das gleiche wie schreiben

3[a] = 'x';

Ich weiß, dass die Frage beantwortet ist, aber ich konnte nicht widerstehen, diese Erklärung zu teilen.

Ich erinnere mich an die Prinzipien des Compiler-Designs. Nehmen wir an, es ahandelt sich um ein intArray mit einer Größe von int2 Bytes und einer Basisadresse von a1000.

Wie a[5]wird es funktionieren ->

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

Damit,

In ähnlicher Weise 5[a]wird ->, wenn der c-Code in 3-Adressen-Code zerlegt wird, ->

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

Im Grunde genommen zeigen beide Anweisungen auf dieselbe Stelle im Speicher und damit auf a[5] = 5[a] .

Diese Erklärung ist auch der Grund, warum negative Indizes in Arrays in C funktionieren.

dh wenn ich darauf zugreife a[-5], werde ich es geben

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

Es wird mir Objekt an Position 990 zurückgeben.

In C-Arrays sind arr[3]und 3[arr]gleich, und ihre äquivalenten Zeigernotationen sind *(arr + 3)zu *(3 + arr). Aber im Gegenteil [arr]3oder [3]arrist nicht korrekt und führt zu Syntaxfehlern, da (arr + 3)*und (3 + arr)*keine gültigen Ausdrücke sind. Der Grund dafür ist, dass der Dereferenzierungsoperator vor der vom Ausdruck angegebenen Adresse und nicht nach der Adresse stehen sollte.

in c Compiler

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

Es gibt verschiedene Möglichkeiten, auf ein Element in einem Array zu verweisen! (Überhaupt nicht seltsam)

Ein bisschen Geschichte jetzt. BCPL hatte unter anderem einen ziemlich großen Einfluss auf die frühe Entwicklung von C. Wenn Sie ein Array in BCPL mit folgenden Elementen deklariert haben:

let V = vec 10

das ordnete tatsächlich 11 Wörter des Speichers zu, nicht 10. Typischerweise war V das erste und enthielt die Adresse des unmittelbar folgenden Wortes. Im Gegensatz zu C ging der Name V an diesen Ort und nahm die Adresse des nullten Elements des Arrays auf. Daher Array-Indirektion in BCPL, ausgedrückt als

let J = V!5

musste wirklich tun J = !(V + 5)(unter Verwendung der BCPL-Syntax), da es notwendig war, V abzurufen, um die Basisadresse des Arrays zu erhalten. So V!5und5!V waren auch. Als anekdotische Beobachtung wurde WAFL (Warwick Functional Language) in BCPL geschrieben, und nach bestem Wissen verwendete ich eher die letztere Syntax als die erstere für den Zugriff auf die als Datenspeicher verwendeten Knoten. Zugegeben, das ist irgendwo vor 35 bis 40 Jahren, also ist meine Erinnerung ein wenig verrostet. :) :)

Die Neuerung, auf das zusätzliche Speicherwort zu verzichten und den Compiler die Basisadresse des Arrays einfügen zu lassen, als es benannt wurde, kam später. Laut dem C-Geschichtspapier geschah dies ungefähr zu dem Zeitpunkt, als Strukturen zu C hinzugefügt wurden.

Beachten Sie, dass !BCPL in beiden Fällen sowohl ein unärer Präfixoperator als auch ein binärer Infixoperator war und in beiden Fällen eine Indirektion durchführte. nur dass die binäre Form eine Addition der beiden Operanden vor der Indirektion enthielt. Angesichts der wortorientierten Natur von BCPL (und B) war dies tatsächlich sehr sinnvoll. Die Einschränkung von "Zeiger und Ganzzahl" wurde in C notwendig, als es Datentypen gewann, und sizeofwurde zu einer Sache.

Nun, dies ist eine Funktion, die nur aufgrund der Sprachunterstützung möglich ist.

Der Compiler interpretiert a[i]als *(a+i)und der Ausdruck wird als 5[a]ausgewertet *(5+a). Da die Addition kommutativ ist, stellt sich heraus, dass beide gleich sind. Daher ergibt der Ausdruck zu true.

In 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

Zeiger ist eine "Variable"

Der Array-Name ist eine "Mnemonik" oder ein "Synonym".

p++;ist gültig, aber a++ungültig

a[2] ist gleich 2 [a], da die interne Operation für beide ist

"Zeigerarithmetik" intern berechnet als

*(a+3) gleich *(3+a)

Zeigertypen

1) Zeiger auf Daten

int *ptr;

2) const Zeiger auf Daten

int const *ptr;

3) const Zeiger auf const Daten

int const *const ptr;

und die Arrays sind vom Typ (2) aus unserer Liste.
Wenn Sie ein Array gleichzeitig definieren, wird eine Adresse in diesem Zeiger initialisiert.
Da wir wissen, dass wir den const-Wert in unserem Programm nicht ändern oder modifizieren können, wird beim Kompilieren ein FEHLER ausgelöst Zeit

Der Hauptunterschied, den ich gefunden habe, ist ...

Wir können den Zeiger durch eine Adresse neu initialisieren, aber nicht den gleichen Fall mit einem Array.

======
und zurück zu Ihrer Frage ...
a[5]ist nichts, aber *(a + 5)
Sie können es leicht verstehen, indem Sie
a die Adresse (die Leute nennen sie als Basisadresse) genau wie einen (2) Zeigertyp in unserer Liste enthalten
[]- dieser Operator kann durch Zeiger austauschbar *.

so endlich...

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