Also wir hatten uns das letzte Mal ja mit der Thematik Zeige, Arithmetik und Felder beschäftigt und jetzt vielleicht noch mal ganz kurz so die

die wesentlichen Elemente an den Stellen, wo wir letztlich diese quasi Gleichheit von diesen beiden Konstruktionen haben.

Also einerseits, wir haben Feldnamen. Feldnamen können wir verwenden wie, also so was, wenn wir hier was anlegen, wie, ja hier war das Kommer verkehrt, also integer array von n und Stern ip ist gleich array.

Dann ist also so, dass der Feldname letztendlich einem Zeiger auf das Nolte-Feld-Element entspricht. Also array von Null und Operator drauf angewendet, liefert ja dann die Adresse von dem Nolten-Feld-Element.

Nachdem IP, der Zeiger IP, ja auf das Array zeigt, ah ja, hier muss man auch nochmal

Obacht geben, also deswegen ist dieses Komma hier ganz wichtig, dass das da nicht steht.

Also integer array von N, Komma, Stern, IP gleich Array. Ja, das ist insgesamt eine

Definition von einem Feld und einer Variablen, ja, in einer Zeile kann man machen so.

Und deswegen hier auch der Stern vor dem Stern IP. Im Endeffekt dieser Stern hier zusammen mit

diesem integer hier vorne bildet den Typ von der Variablen IP.

Also das hatten wir jetzt ein paar Mal schon, das sind die Variablen Definitionen bei den Pointeren,

dass der Stern einerseits zum Typ dazu gehört, aber genauso wie ich eben hinschreiben kann,

integer A, B, C, da steht der Typ vorne und dann kommen drei Variablen von diesem Typ.

Aber ich kann eben nicht hinschreiben integer Stern P1, P2, P3, denn der Stern, also quasi der Stern

als Teil des Typs bezieht sich aber dann nur auf die eine Variable. Wenn das hier auch Pointer

sein sollen, muss ich den Stern hier jeweils auch noch davor schreiben.

Also eine etwas komische Art und Weise, wie das, wie quasi der Typ, obwohl der Typ ja für sich selbst

auf jeden Fall ein integer Stern ist, wie der Typ dann in so einer Variablen Definition irgendwie

aufgesplittet ist, einerseits quasi in den Basis-Typ und dann so diese Pointer-Komponente davon,

die man dann für jede Variable davon iterieren muss. Und genau so wie hier im gleichen Schema hat auch

der Stern hier an dieser Stelle die Bedeutung. Also im Prinzip, diese Zeile bezieht sich also auf den Typ

integer und jetzt haben wir ein Feld von n Elementen und wir haben einen Pointer, den wir

irgendwie initialisieren. Und da ist es jetzt also tatsächlich so, dass das eben Array von 0,

also der Adresse von Array von 0 eben das gleiche ist wie der Feldname und nachdem IP mit dem Feldname

initialisiert wurde, also der Zeiger, auf das den Feld beginnt, wurde auch diesem Zeiger dieser

Variablen IP zugewiesen, ist das also identisch mit dem IP und ich kann aber auch IP mit diesen

eckigen Klammern verwenden und auf die Weise auf die einzelnen Feld-Elemente oder ich kann diese

Pointer-Arithmetik letztendlich betreiben an der Stelle, weil der eckige Klammer-Operator ist ja

nichts anderes, wie irgendwie eine etwas schöner dargestellte Pointer-Arithmetik mit der

Referenzierung. Was wir also hier unten in der dritten Zeile recht schön sehen, also Array von i

ist im Prinzip nichts anderes wie Array plus i, hier ja wieder die Pointer-Arithmetik, also es wird

die Größe eines Feld-Elements berücksichtigt, also es wird quasi der Zeiger, auf diesen Zeiger werden

die Größe von i Elementen draufaddiert, da kommt ein neuer Zeiger raus und der wird

referenziert und das ist genau das, was der eckige Klammer-Operator tut, das kann ich auch bei einem

Pointer anwenden und genauso kann ich das, also hier auch, ich habe die Folien seit der letzten Woche

jetzt nicht korrigiert, also hier muss auch wieder ein i stehen statt der eins und das ist wieder das

identische zu ip von i. So, also das war diese Äquivalenz von Feldern und Zeigern, aber eben nicht

völlig äquivalent, denn was wir nicht machen können, ist eben, wir können den Feld, den Zeiger auf das

erste Feld-Element, den Feldnamen, den können wir nicht modifizieren, wir können also nicht so etwas

wie array++ machen, während wir natürlich die Pointer-Variable ip, die können wir modifizieren,

denn das ist ja eine Variable, während das array ist eine Konstante. So, das Beispiel gehe ich jetzt

nicht nochmal durch. Ja, dann hatten wir kurz über mehrdimensionale Felder gesprochen, auch das, denke

ich, müssen wir heute nicht nochmal ansprechen, dynamische Speicherverwaltung hatten wir letzte Woche

angesprochen, ganz wichtig hier nochmal diese malloc-Funktion, die wir immer dann brauchen, wenn wir

Felder einer beim Programmstart nicht bekannten Größe allokieren wollen oder überhaupt irgendwelche

Datenobjekte in irgendeine Anzahl allokieren wollen, die zu Beginn des Programmstarts nicht bekannt

ist. Dynamisch Daten allokieren können wir einerseits auf dem Stack, das heißt also im Bereich der

lokalen Variablen, der automatic Variablen, wenn also eine Funktion betreten wird, dass dann der

Speicherplatz dafür angelegt wird, an der Stelle kann man dann auch ein Feld variabler Größe anlegen,

die Größe muss halt beim Betreten der Funktion bekannt sein und nachdem der Speicherplatz ja erst