# 2.5 Arrays Quelle: https://inf.zone/lectures/2-arrays/short-2-5-arrays/ ## Video [Video ansehen](https://oc.streams.uni-bamberg.de/paella7/ui/watch.html?id=cd3fd5f2-6bd7-45e2-9410-b453a3c046e8) ### Alternativen - [Video auf YouTube](https://youtu.be/0PH-FamCRt8) - Download (1080p) (demnächst) - Download (720p) (demnächst) - Download (540p) (demnächst) ## Hinweise zu diesem Video **Korrekturen** Die Korrekturen betreffen das Video. In den Folien zum Herunterladen sind sie eingearbeitet, soweit sie die Folien betreffen. - Folie 12: In unserer Umgebung lässt sich das Beispiel so nicht übersetzen. Der Compiler bricht mit der Meldung „parameter x set but not used“ ab, weil set\_int den geänderten Parameter nie verwendet. Die Aussage der Folie stimmt trotzdem: Die Zuweisung an x ändert nur die Kopie, a bleibt 10. ## Was davon zur Basis gehört Der Hauptteil dieses Shorts gehört ganz zur Basis. - **Programmieren können** (Basis-Code): Arrays von Zahlen, auch zweidimensional, an Funktionen übergeben (mit Länge) - „Die drei Extra-Minuten“ (ab Folie 13): **Kür**. Was die Labels bedeuten, steht unter [Was Sie zum Bestehen können müssen](https://inf.zone/extras/lernen/#was-sie-zum-bestehen-können-müssen). ## Material - [Folien](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf) - Folien und Transkript: unten auf dieser Seite ## Folien und Transkript *Folientext aus den PDF-Folien, darunter jeweils der gesprochene Text des Videos. Der gesprochene Text ist maschinell transkribiert und nachkorrigiert, kann aber noch Fehler enthalten; im Video sprechen abwechselnd Prof und eine AI-Figur, die Sprecherwechsel sind nicht markiert. Die Zuordnung zu den Folien ist ungefähr. Die Zeitangaben verlinken auf die Stelle im Video (YouTube). Maßgeblich sind Video und Folien.* ### Folie 1 — Arrays [Folie 1 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=1) #### Transkript **[Video 00:00–00:29](https://www.youtube.com/watch?v=0PH-FamCRt8&t=0)** Dies ist Inf-Einf-B. Heute Arrays. Hallo und herzlich willkommen zu unserer heutigen Vorlesung. Ich hoffe, du hast deinen Kaffee schon getrunken, denn wir werden gleich in die faszinierende Welt der Arrays eintauchen. ### Folie 2 [Folie 2 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=2) Arrays sind eine sehr nützliche und fundamentale Datenstruktur. Sie speichern Werte des gleichen Datentyps an zusammenhängenden Speicherorten. Wie die Postfächer in einer Postfiliale: Große Wand mit vielen gleich großen Fächern. Jedes Fach kann einen bestimmten Inhalt aufnehmen und es ist ein direkter Zugriff über eine Nummer möglich. #### Transkript **[Video 00:00–00:29](https://www.youtube.com/watch?v=0PH-FamCRt8&t=0)** Arrays sind wirklich grundlegend für die Programmierung und extrem nützlich. Na, na, na, nicht schon wieder in die Welt eintauchen. Das klingt ja wie so ein Sprachmodell von der Stange. Komm zum Punkt und fang halt einfach an. Oh, Entschuldigung. **[Video 00:29–00:59](https://www.youtube.com/watch?v=0PH-FamCRt8&t=29)** Dann legen wir gleich los. Wie gesagt, Arrays sind eine fundamentale Datenstruktur in der Programmierung. Wir verwenden sie, um Werte desselben Typs hintereinander im Speicher abzulegen. Eine Möglichkeit, sich Arrays vorzustellen, ist der Vergleich mit einer Postfiliale. Stellen Sie sich eine große Wand voller Postfächer vor. Gute Analogie. Aber ehrlich gesagt weiß ich nicht, wie viele unserer Studierenden wissen, was du meinst. Ich fürchte, die haben noch nie eine so große Wand mit Postfächern gesehen. ### Folie 3 [Folie 3 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=3) > Bildinhalte sind nicht transkribiert; siehe Originalfolie. > Vorwiegend grafische Folie; die extrahierten Beschriftungen ersetzen die Abbildung nicht. > Kein auslesbarer Text auf dieser Folie. #### Transkript **[Video 00:29–00:59](https://www.youtube.com/watch?v=0PH-FamCRt8&t=29)** Wie wäre es denn mit einem Bild? Natürlich. Hier bitte sehr. **[Video 00:59–01:31](https://www.youtube.com/watch?v=0PH-FamCRt8&t=59)** Ernsthaft? Da haben ja mehrere Postfächer die gleiche Nummer. Verzeihung, ich versuche es noch einmal. Ja, schon besser. ### Folie 4 [Folie 4 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=4) > Bildinhalte sind nicht transkribiert; siehe Originalfolie. > Vorwiegend grafische Folie; die extrahierten Beschriftungen ersetzen die Abbildung nicht. > Kein auslesbarer Text auf dieser Folie. #### Transkript **[Video 00:59–01:31](https://www.youtube.com/watch?v=0PH-FamCRt8&t=59)** Ich glaube, es ist klar, was gemeint ist. ### Folie 5 — Arrays Postfächer [Folie 5 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=5) Block zusammenhängenden Speichers Große Wand in der Postfiliale Unterteilt in Elemente Unterteilt in Postfächer Jedes Element speichert bestimmte Datenmenge Jedes Fach enthält bestimmte Postmenge Alle Elemente vom gleichen Datentyp Verschiedene Postarten möglich Zugriff auf Elemente über Index Zugriff auf Inhalt über Fachnummer Indizierung beginnt bei 0 Nummerierung beginnt bei 1 #### Transkript **[Video 00:59–01:31](https://www.youtube.com/watch?v=0PH-FamCRt8&t=59)** Weiter. Also stellen Sie sich vor, jedes Postfach entspricht einem Element im Array. Genau so, wie die Postfächer alle gleich groß sind und nacheinander angeordnet, sind auch die Elemente eines Arrays gleich groß und liegen im Speicher direkt nebeneinander. Und wie bei so einer Wand mit vielen Postfächern kann man auch bei Arrays direkt auf bestimmte Elemente zugreifen und zwar über ihren Index. Dazu kommen wir aber gleich noch. **[Video 01:31–02:04](https://www.youtube.com/watch?v=0PH-FamCRt8&t=91)** Lassen Sie uns den Vergleich zwischen Arrays und Postfächern noch etwas vertiefen. Ein Array ist wie ein Block zusammenhängenden Speichers, ähnlich wie eine Wand in der Postfiliale ein großer zusammenhängender Raum ist. Dieser Speicherblock wird in kleinere gleich große Abschnitte unterteilt, die wir Elemente nennen, genau wie die Wand in kleinere gleich große Postfächer unterteilt ist. Das ist eine gute Analogie. Aber was kann man denn in diesen Array-Fächern aufbewahren? Gute Frage. In jedem Element eines Arrays können wir eine bestimmte Menge an Daten speichern, so wie in jedem Postfach eine bestimmte Menge an Post Platz findet. **[Video 02:04–02:33](https://www.youtube.com/watch?v=0PH-FamCRt8&t=124)** Der Unterschied ist, dass in einem Array alle Elemente denselben Datentyp haben müssen, zum Beispiel nur Ganzzahlen oder nur Zeichen. Bei Postfächern ist man da flexibler, da passen Briefe und kleine Pakete gleichermaßen rein. Ja, verstehe ich. Und wie greift man jetzt auf diese Elemente zu? ### Folie 6 — Arrays in C [Folie 6 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=6) Die Indizierung beginnt bei 0. In Schleifen beginnt die Zählung daher üblicherweise bei 0. Array mit n Elementen: Erstes Element hat Index 0. Letztes Element hat Index n–1. Zugriffe auf höhere Indizes als n–1 werden von C grundsätzlich nicht verhindert – können zu Fehlern oder Abstürzen führen („out of bounds“). Tipp: Stellen Sie sich den Index als „Anzahl der Schritte vom Anfang“ vor. #### Transkript **[Video 02:04–02:33](https://www.youtube.com/watch?v=0PH-FamCRt8&t=124)** Genau wie bei Postfächern, die eine Nummer haben, kann man auf jedes Element eines Arrays direkt über einen Index zugreifen. Der große Unterschied ist allerdings, dass wir in der Programmierung, speziell in C, bei Null zu zählen anfangen. Dazu gleich mehr. **[Video 02:33–02:59](https://www.youtube.com/watch?v=0PH-FamCRt8&t=153)** Kommen wir nun zu den Besonderheiten von Arrays in C. In C werden die Elemente eines Arrays ab null indiziert. Das ist einer der Hauptgründe, warum wir in der Informatik oft bei null zu zählen beginnen. Ja schon. Das kann für Anfänger aber ziemlich verwirrend sein. Hast du vielleicht einen Tipp, wie man sich das besser merken kann? Absolut. Stellen Sie sich vor, der Index gibt an, wie weit ein Element vom Anfang des Arrays entfernt ist. Das erste Element ist null Schritte entfernt, das zweite eins Schritt. **[Video 02:59–03:31](https://www.youtube.com/watch?v=0PH-FamCRt8&t=179)** und so weiter. Das hilft vielen, sich die Null-Indizierung besser zu merken. Nun zur Größe eines Arrays. Wenn ein Array aus n Elementen besteht, befindet sich das erste Element an Index null und das letzte an Index n minus eins. Das ist wichtig zu beachten, um nicht versehentlich über die Grenzen des Arrays hinauszugehen. Apropos Grenzen überschreiten: Was passiert denn, wenn man das tut? Gute Frage. C ist da leider sehr nachsichtig. Es wird Sie nicht daran hindern, über die Grenzen Ihres Arrays hinauszugehen. Das kann zu unvorhersehbarem Verhalten oder sogar Abstürzen führen. Daher ist es wichtig ### Folie 7 — Deklaration [Folie 7 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=7) ```text type name[size]; ``` und Zugriff type: Datentyp jedes Elements (z.B. int oder double) name: Bezeichnung des Arrays size: Anzahl der Elemente Beispiel für Deklaration: ```text int student_grades[40]; double menu_prices[8]; ``` Beispiel für Zugriff: ```text student_grades[2] = 95; if(menu_prices[0] > 10.0) { … } ``` #### Transkript **[Video 03:31–04:00](https://www.youtube.com/watch?v=0PH-FamCRt8&t=211)** besonders vorsichtig zu sein und die Grenzen des Arrays immer im Auge zu behalten. Kommen wir nun zu Array-Deklarationen in C. Eine Array-Deklaration besteht aus drei Teilen: dem Typ, dem Namen und der Größe. Der Typ gibt an, welche Art von Variablen jedes Element des Arrays sein wird. Der Name ist, wie Sie sich denken können, die Bezeichnung, die Sie Ihrem Array geben möchten. Die Größe, die in eckigen Klammern angegeben wird, legt fest, wie viele Elemente Ihr Array enthalten soll. Hier sind zwei Beispiele: int student_grades in eckigen Klammern 40. **[Video 04:00–04:28](https://www.youtube.com/watch?v=0PH-FamCRt8&t=240)** Dies deklariert ein Array namens student_grades, das aus 40 Ganzzahlen besteht. double menu_prices in eckigen Klammern 8. Dies erstellt ein Array namens menu_prices, das Platz für acht Gleitkomma-Zahlen bietet. Wenn Sie ein einzelnes Element eines Arrays verwenden, können Sie es wie jede andere Variable des gleichen Typs behandeln. ### Folie 8 — Initialisierung [Folie 8 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=8) Spezielle Syntax bei gleichzeitiger Deklaration und Initialisierung: ```text typ name[] = { wert1, wert2, … }; ``` Beispiel: ```text bool truthtable[3] = { false, true, true }; ``` Äquivalent zu: ```text bool truthtable[] = { false, true, true }; ``` Zugriff auf Elemente: ```text truthtable[0] = true; if (truthtable[2] == true) { … } ``` #### Transkript **[Video 04:00–04:28](https://www.youtube.com/watch?v=0PH-FamCRt8&t=240)** Das bedeutet, Sie können ihm Werte zuweisen, es in Bedingungen verwenden und so weiter. Wenn Sie ein Array deklarieren und gleichzeitig initialisieren möchten, gibt es dafür eine spezielle Syntax. **[Video 04:28–04:58](https://www.youtube.com/watch?v=0PH-FamCRt8&t=268)** Anstatt jedes Element einzeln zuzuweisen, können Sie eine Liste von Startwerten in geschweiften Klammern angeben. Hier ein Beispiel: bool truthtable\[3\] ist gleich in geschweiften Klammern false true true. Dies erstellt ein Array namens truthtable mit drei booleschen Werten. Die Werte werden in der Reihenfolge zugewiesen, in der sie in den geschweiften Klammern stehen. Interessanterweise können Sie bei dieser Initialisierungssyntax die Größe des Arrays auch weglassen. Der Compiler ist schlau genug, die Größe anhand der Anzahl der angegebenen Elemente zu bestimmen. Also **[Video 04:58–05:23](https://www.youtube.com/watch?v=0PH-FamCRt8&t=298)** wäre Folgendes zum vorherigen Äquivalent: bool truthtable, eckige Klammer auf und gleich wieder zu und so weiter. Beachten Sie, dass diese Kurzschreibweise nur bei der Initialisierung funktioniert. Wenn Sie später auf Elemente des Arrays zugreifen oder sie ändern möchten, müssen Sie wie gewohnt den Index verwenden. ### Folie 9 — Mehrdimensionale Arrays [Folie 9 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=9) ```text typ name[size1][size2]… ; ``` Beispiel „Schiffe versenken“: ```text bool battleship[10][10]; ``` Erzeugt ein 10x10 Spielfeld (2D-Matrix); Intern: 100 Elemente in Reihe. Beispiel für den Zugriff: ```text battleship[0][9] = true; ``` Es gilt: ```text battleship[1][0] == battleship[0][10] ``` (Der Compiler von CS50 wertet dies als Fehler.) #### Transkript **[Video 04:58–05:23](https://www.youtube.com/watch?v=0PH-FamCRt8&t=298)** Arrays müssen sich nicht auf eine einzige Dimension beschränken. In C können wir mehrdimensionale Arrays erstellen, indem wir einfach weitere Größenangaben in eckigen Klammern hinzufügen. **[Video 05:23–05:53](https://www.youtube.com/watch?v=0PH-FamCRt8&t=323)** Ein beliebtes Beispiel dafür ist das Spiel Schiffe versenken. Stellen Sie sich vor, Sie wollen das Spielfeld programmieren. Sie könnten es so deklarieren: bool battleship in eckigen Klammern zehn und danach noch einmal in eckigen Klammern zehn. Dies erzeugt ein zweidimensionales Array mit zehn Zeilen und zehn Spalten. Perfekt für unser Spielfeld mit zehn mal zehn Feldern. Moment mal, heißt das, wir könnten theoretisch auch ein dreidimensionales Schiffe versenken programmieren? Theoretisch ja. Stellen Sie sich vor, U-Boot versenken in 3D. Aber ich fürchte. **[Video 05:53–06:20](https://www.youtube.com/watch?v=0PH-FamCRt8&t=353)** Das würde den Rahmen unserer Vorlesung sprengen und vermutlich auch die Geduld von denen, die das dann spielen sollen. In der Praxis bleiben wir meist bei ein oder zwei Dimensionen. Denken Sie daran: Auch wenn wir das Array mehrdimensional visualisieren, speichert der Computer es linear als eine lange eindimensionale Reihe von Elementen. ### Folie 10 — Zuweisungen [Folie 10 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=10) Einzelne Array-Elemente können wie Variablen behandelt werden. Gesamte Arrays können aber nicht direkt zugewiesen werden: ```text int foo[5] = {1, 2, 3, 4, 5}; int bar[5]; bar = foo; // Fehler! ``` Korrekte Methode (vorerst): ```text for (int j = 0; j < 5; j++) { bar[j] = foo[j]; } ``` Mehr Kontrolle, Vermeidung unbeabsichtigter aufwändiger Kopiervorgänge. #### Transkript **[Video 05:53–06:20](https://www.youtube.com/watch?v=0PH-FamCRt8&t=353)** Ein wichtiger Punkt, den wir bei Arrays beachten müssen, ist, dass wir zwar einzelne Elemente wie Variablen behandeln können, aber nicht das gesamte Array. In C können wir nicht einfach ein Array einem anderen zuweisen. **[Video 06:20–06:48](https://www.youtube.com/watch?v=0PH-FamCRt8&t=380)** Nehmen wir an, wir haben zwei Arrays. int foo fünf ist gleich eins zwei drei vier fünf. Das Array int bar hat auch die Länge fünf. Wir können dann aber nicht schreiben bar ist gleich foo. Das funktioniert nicht. Stattdessen müssen wir eine Schleife verwenden, um die Elemente einzeln zu kopieren. Das mag umständlich erscheinen, aber es gibt gute Gründe dafür. Diese Einschränkung zwingt uns bewusst mit dem Speicher umzugehen und verhindert unbeabsichtigte möglicherweise ressourcenintensive Kopiervorgänge. ### Folie 11 — Übergabe als Referenz [Folie 11 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=11) Erinnern Sie sich daran, dass Variablen in C bei Funktionsaufrufen üblicherweise als Wert übergeben werden. Bei Arrays gilt diese Regel nicht. Sie werden als Referenz übergeben. Die aufgerufene Funktion (Callee) erhält das eigentliche Array, nicht eine Kopie davon. Was bedeutet das, wenn der Callee Elemente im Array verändert? Warum Arrays diese besondere Eigenschaft haben, werden wir vorerst nicht weiter ausführen – aber wir werden demnächst darauf zurückkommen. #### Transkript **[Video 06:48–07:15](https://www.youtube.com/watch?v=0PH-FamCRt8&t=408)** Nun kommen wir zu einem wichtigen Unterschied zwischen Arrays und anderen Variablentypen in C, wenn es um Funktionsaufrufe geht. Wie Sie ja wahrscheinlich noch wissen, werden Variablen in C bei Funktionsaufrufen normalerweise als Wert übergeben. Das bedeutet, die Funktion erhält eine Kopie des Wertes, nicht die Variable selbst. Arrays folgen dieser Regel jedoch nicht. Sie werden stattdessen als Referenz übergeben. Das bedeutet, die aufgerufene Funktion erhält das tatsächliche Array, nicht eine Kopie davon. Moment mal. **[Video 07:15–07:49](https://www.youtube.com/watch?v=0PH-FamCRt8&t=435)** Wir haben doch damals, als wir über die Übergabe als Wert gesprochen haben, diese Analogie mit der nummerierten Schublade verwendet. Jetzt sprechen wir wieder von nummerierten Postfächern. Ist das nicht irgendwie verwirrend für die Studierenden? Stimmt, danke für den Hinweis. Lass mich das kurz klarstellen: Die Analogie der nummerierten Schublade bezog sich auf einzelne Variablen, während unsere Postfach-Analogie für Arrays steht. Bei der Übergabe als Referenz geben wir sozusagen den Schlüssel zum gesamten Postfachblock weiter, nicht nur den Inhalt eines einzelnen Fachs. Um es noch deutlicher zu machen: Bei der Übergabe als Wert kopieren wir den Inhalt von einer Schublade. **[Video 07:49–08:19](https://www.youtube.com/watch?v=0PH-FamCRt8&t=469)** Bei Arrays und der Übergabe als Referenz geben wir den Zugang zum gesamten Postfachblock weiter, ohne etwas zu kopieren. Warum das so ist und wie es genau funktioniert, werden wir in einer späteren Vorlesung detaillierter besprechen. Für den Moment ist es wichtig zu verstehen, dass Änderungen an einem Array innerhalb einer Funktion sich auf das ursprüngliche Array auswirken. Mhm, danke für die Klarstellung. Es ist wichtig, dass die Studierenden den Unterschied schon jetzt kennen, auch wenn wir die Details erst später behandeln. ### Folie 12 — Beispiel [Folie 12 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=12) Beispiel ```c int set_int(int x) { x = 22; return x; } void set_array(int array[4]) { array[0] = 22; } int main(void) { int a = 10; int b[4] = {0, 1, 2, 3}; set_int(a); set_array(b); printf("%d %d\n", a, b[0]); } ``` Ausgabe: `10 22` Begründung: `a` bleibt 10 (Übergabe als Wert) `b[``0``]` wird zu 22 (Übergabe als Referenz) #### Transkript **[Video 07:49–08:19](https://www.youtube.com/watch?v=0PH-FamCRt8&t=469)** Das ist beim Lernen einer Programmiersprache ziemlich oft so. **[Video 08:19–08:53](https://www.youtube.com/watch?v=0PH-FamCRt8&t=499)** Man muss es eine Weile lang aushalten, dass man manches nicht versteht. Mit der Zeit versteht man aber die Zusammenhänge dann immer besser. Um den Unterschied zwischen der Übergabe als Wert und als Referenz zu veranschaulichen, betrachten wir ein konkretes Beispiel. Hier haben wir zwei Funktionen: set\_int und set\_array. set\_int bekommt eine Ganzzahl übergeben. set\_array bekommt stattdessen einen Array übergeben. Hier sehen Sie auch gleich die Syntax für eine Funktion, die Arrays entgegennimmt. Die Funktion set\_array erwartet also ein Ganzzahl-Array mit vier Elementen. In der Hauptfunktion rufen wir diese beiden Funktionen dann auf. **[Video 08:53–09:21](https://www.youtube.com/watch?v=0PH-FamCRt8&t=533)** Danach geben wir den Wert der Variablen a aus, nachdem wir ihn an die Funktion set\_int übergeben haben. Außerdem schauen wir uns das erste Element, Verzeihung, das nullte Element des Arrays b an, das wir zuvor an set\_array übergeben hatten. Die Frage ist nun, was wird dieses Programm ausgeben? Die Antwort lautet 10 22. Der Wert von a bleibt unverändert, weil set\_int eine Kopie erhält. Der Wert von b\[0\] wird jedoch auf 22 geändert, weil set\_array eine Referenz auf das Originalarray erhält. So. **[Video 09:21–09:53](https://www.youtube.com/watch?v=0PH-FamCRt8&t=561)** Das war unsere Einführung in Arrays. ### Folie 13 [Folie 13 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=13) E X T R A S I N 3 M I N U T E N FRAGEN – ANTWORTEN – RÄTSEL UND KURZE ZUSAMMENFASSUNG #### Transkript **[Video 09:21–09:53](https://www.youtube.com/watch?v=0PH-FamCRt8&t=561)** Damit kommen wir zum Abschluss unserer heutigen Vorlesung. Jetzt folgt noch unser Segment die drei Extra Minuten. Aha, endlich wieder ein Video mit den drei Extra Minuten. Eine gute Gelegenheit für die Studierenden, das Gelernte zu wiederholen. Denk dir mal drei Wiederholungsfragen aus. Das fördert das aktive Erinnern und hilft beim Lernen. Natürlich. Aktives Wiederholen ist tatsächlich eine sehr effektive Lernmethode. Hier sind drei Fragen, die die Hauptpunkte unserer heutigen Vorlesung abdecken. Am besten denken Sie nicht nur darüber nach, sondern schreiben sich Ihre Antworten auf. **[Video 09:53–10:25](https://www.youtube.com/watch?v=0PH-FamCRt8&t=593)** Das verstärkt den Lerneffekt zusätzlich. Das sind echt gute Fragen. Zum Abschluss hätte ich gerne noch ein kleines Rätsel, vielleicht ein so ein Codeschnipsel, der auf den ersten Blick irgendwie seltsam aussieht, aber einen subtilen Programmierfehler enthält. Gerne. Hier ist ein kleines Coderätsel für unsere Studierenden. Was wird dieser Code ausgeben und warum? Nehmen Sie sich einen Moment Zeit, um darüber nachzudenken. Okay, lassen Sie mich das auflösen. ### Folie 14 [Folie 14 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=14) F1: Warum beginnt die Indizierung von Arrays in C bei 0 und nicht bei 1? F2: Wie würden Sie ein zweidimensionales Array für ein Schachbrett deklarieren? F3: Welcher Unterschied besteht zwischen der Übergabe eines einzelnen Integers und eines Integer-Arrays an eine Funktion? #### Transkript **[Video 09:53–10:25](https://www.youtube.com/watch?v=0PH-FamCRt8&t=593)** Der subtile Fehler hier ist die Bedingung in der for-Schleife. Wir haben i kleiner gleich fünf, aber da die Indizierung bei null beginnt, geht unser Array nur von null bis vier. **[Video 10:25–10:50](https://www.youtube.com/watch?v=0PH-FamCRt8&t=625)** Bei der letzten Iteration versuchen wir also auf zahlen fünf zuzugreifen, was außerhalb unseres Arrays liegt. Dies kann zu unvorhersehbarem Verhalten führen. Wir greifen auf einen Speicherbereich zu, der nicht zu unserem Array gehört. In der Praxis könnte dies zu einer Fehlermeldung führen oder noch schlimmer zu schwer zu findenden Softwarebugs, wenn zufällig Daten an dieser Speicherstelle liegen, die einigermaßen sinnvoll sind. Die korrekte Schleifenbedingung wäre i kleiner fünf oder i kleiner gleich vier. **[Video 10:50–11:23](https://www.youtube.com/watch?v=0PH-FamCRt8&t=650)** Das war mir jetzt ehrlich gesagt zu einfach. Ich habe ein besseres Rätsel für unsere Studierenden. Schau mal. Was denkst du, wird das Programm laufen? Und warum habe ich dieses Beispiel gewählt? Oh, mal sehen. Interessant. Das ist in der Tat eine interessante Aufgabe. Lass mich das kurz analysieren. Zunächst einmal, ja, das Programm wird kompilieren und laufen, aber es wird vielleicht nicht das tun, was man auf den ersten Blick erwarten würde. Schauen wir uns an, was hier passiert. Wir deklarieren ein zweidimensionales Array arr mit zwei Zeilen und drei Spalten. **[Video 11:23–11:48](https://www.youtube.com/watch?v=0PH-FamCRt8&t=683)** Die erste verschachtelte Schleife füllt das Array mit Werten von 0 bis 5, so wie es der Kommentar andeutet. Die zweite Schleife ist der Knackpunkt. Sie läuft sechsmal durch, aber greift immer auf arr\[0\]\[i\] zu, verletzt dabei also die Grenze des inneren Arrays, das ja nur aus drei Elementen besteht. Das Interessante ist: Das geht. In C werden mehrdimensionale Arrays im Speicher nämlich linear angeordnet. Ah, jetzt verstehe ich. **[Video 11:48–12:17](https://www.youtube.com/watch?v=0PH-FamCRt8&t=708)** Ich habe das ja schon vorhin en passant erwähnt, habe es dann aber nicht genauer erklärt, weil ich dachte, dass die Studierenden schon wissen, wie Arrays im Speicher abgelegt werden. Ist die Aufgabe vielleicht ein subtiler Hinweis für mich? Wie sagt ihr, ein Wink mit dem Zaunpfahl? Haha. Na gut, Treffer versenkt. Ich werde mich bemühen, in Zukunft besser zu erklären. Also, bei mehrdimensionalen Arrays liegen die inneren Arrays direkt hintereinander im Speicher. Das zweidimensionale Array, um das es geht, besteht ja eigentlich aus zwei eindimensionalen Arrays. **[Video 12:17–12:49](https://www.youtube.com/watch?v=0PH-FamCRt8&t=737)** mit jeweils drei Elementen. Das heißt, es liegen sechs Ganzzahlen hintereinander im Speicher. Das bedeutet, arr\[0\]\[3\], arr\[0\]\[4\] und arr\[0\]\[5\] greifen tatsächlich auf arr\[1\]\[0\], arr\[1\]\[1\] und arr\[1\]\[2\] zu. Das Programm wird also folgende Ausgabe produzieren: 00, 11, 22, 33, 44, 55. Verrückt, oder? Dieses Beispiel zeigt, warum das Verständnis der Speicheranordnung von Arrays so wichtig ist. So, jetzt sind wir aber wirklich tief in die Welt der Arrays eingetaucht. **[Video 12:49–13:18](https://www.youtube.com/watch?v=0PH-FamCRt8&t=769)** Nicht schon wieder dieses Welteintauchen. ### Folie 15 [Folie 15 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=15) ```c int main() { int zahlen[5] = {1, 2, 3, 4, 5}; for(int i = 0; i <= 5; i++) { printf("%d ", zahlen[i]); } return 0; } ``` #### Transkript > Zuordnung unsicher: wenige gemeinsame Textmerkmale; anhand der benachbarten Folien eingeordnet. **[Video 12:49–13:18](https://www.youtube.com/watch?v=0PH-FamCRt8&t=769)** Ich dachte, wir hatten das geklärt. Oh, Entschuldigung, da bin ich wohl in alte Gewohnheiten zurückgefallen. Lass es mich anders ausdrücken: Unser Ausflug zur Postfiliale der Programmierung ist damit beendet. Bis zum nächsten Mal, wenn wir in die Welt, ich meine, wenn wir dann das nächste Thema anpacken. Ja, ja, ist schon recht jetzt. Damit verabschieden wir uns. Bis bald. Dies war Inf-Einf-B. ### Folie 16 [Folie 16 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=16) ```c #include int main(void) { int arr[2][3]; // fill array (arr[0][0] = 0 … arr[1][2] = 5) for (int i = 0, counter = 0; i < 2; i++) { for (int j = 0; j < 3; j++) { arr[i][j] = counter++; } } for (int i = 0; i < 2 * 3; i++) { printf("[%d] = %d\n", i, arr[0][i]); } } ``` #### Transkript *Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.* ### Folie 17 — Arrays sind zusammenhängende [Folie 17 als PDF](https://inf.zone/download/lectures/2-arrays/2.5-arrays.pdf#page=17) Initialisierung: Speicherblöcke für Elemente gleichen Typs typ name\[\] = {wert1, wert2, ...}; Indizierung beginnt in C bei 0, bei n Elementen ist der letzte Index also (n–1) Mehrdimensionale Arrays werden im Speicher linear angeordnet Deklaration: typ name\[größe\]; Arrays werden an Funktionen „als Referenz“ übergeben, nicht „als Wert“ z.B. int zahlen\[5\]; > Bildinhalte sind nicht transkribiert; siehe Originalfolie. #### Transkript *Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*