# 2.2 Scope

Quelle: https://inf.zone/lectures/2-arrays/short-2-2-scope/

## Video

[Video ansehen](https://oc.streams.uni-bamberg.de/paella7/ui/watch.html?id=879c1ff4-3bfb-496b-891e-16b9ee439340)

### Alternativen

- [Video auf YouTube](https://youtu.be/bZcHjHxt5-c)
- Download (1080p) (demnächst)
- Download (720p) (demnächst)
- Download (540p) (demnächst)

## Was davon zur Basis gehört

Der Hauptteil dieses Shorts gehört ganz zur Basis.

- **Programmieren können** (Basis-Code): Funktionen, Parameter, Rückgabewerte, Scope
- „Die drei Extra-Minuten“ (ab Folie 13): **Basis.** Sie üben und wiederholen den Stoff des Hauptteils.

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.2-scope.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 — Scope

[Folie 1 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=1)

#### Transkript

**[Video 00:00–00:29](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=0)**

Dies ist Inf-Einf-B. Heute Scope. Hallo, hörst du mich? Ist das Mikro schon an? Ah, ja. Wolltest nicht du heute das Video anmoderieren? Oder täusche ich mich da?

### Folie 2

[Folie 2 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=2)

Der Geltungsbereich (Scope) ist eine Eigenschaft einer Variable, die definiert, von welchen Funktionen aus auf die Variable zugegriffen werden kann.

Lokale Variablen: Nur innerhalb der Funktion, in der sie erstellt wurden, zugänglich.

Globale Variablen: Von jeder Funktion im Programm aus zugänglich.

#### Transkript

**[Video 00:00–00:29](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=0)**

Ja. Hallo und herzlich willkommen zum Video heute über den Geltungsbereich von Variablen.

**[Video 00:29–00:56](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=29)**

Also ich, also ich spreche hier halt in einem leeren Raum und so richtig wohl fühle ich mich dabei halt nicht. Keine Sorge, ich bin doch da und höre dir aufmerksam zu. Und falls du mal einen Fehler machst, springe ich natürlich gerne ein und korrigiere dich gleich. Stimmt, ja, das ist ja toll. Weißt du was? Fang doch lieber wieder du an. Erklär doch den Studierenden mal, warum der Geltungsbereich von Variablen wichtig ist.

**[Video 00:56–01:28](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=56)**

Gerne. Pass auf, wir schauen uns heute den Geltungsbereich von Variablen an. Im Englischen nennt man das den Scope einer Variable. Ich habe mir eine anschauliche Erklärung überlegt. Einen trockenen Einstieg mit einer Definition aus dem Lehrbuch magst du ja nicht.

### Folie 3 — Lokale Variablen

[Folie 3 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=3)

int triple(int x); // Prototyp

int main(void) {

int result = triple(5); }

int triple(int x) {

return x \* 3; }

x ist lokale Variable in triple(); keine andere Funktion kann auf diese Variable zugreifen.

result ist lokale Variable in main().

#### Transkript

**[Video 00:56–01:28](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=56)**

Jetzt bin ich aber gespannt. Bisher haben Sie in diesem Kurs höchstwahrscheinlich nur mit lokalen Variablen gearbeitet. Am besten schauen wir uns dazu gemeinsam ein Beispiel an, damit Sie sehen, was ich meine. So ein Beispiel ist zum Erklären ja immer sehr hilfreich. Also hier sehen wir eine sehr einfache Hauptfunktion und eine zusätzliche Funktion.

**[Video 01:28–01:55](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=88)**

Die wir geschrieben haben. In diesem Fall ist x, das ich grün markiert habe, um den Geltungsbereich dieser Variable hervorzuheben, lokal zur Funktion triple. Die Funktion main kann überhaupt nicht auf x zugreifen. Sie weiß nicht, was x ist. Auch könnte keine andere Funktion, falls wir hier zusätzliche Funktionen hätten, auf x zugreifen. Ähnlich verhält es sich mit result, das ich blau markiert habe. Es ist nur lokal zu main. Nur main weiß, was die Variable result ist. Triple kann sie nicht verwenden.

**[Video 01:55–02:21](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=115)**

Dies verdeutlicht, wie lokale Variablen funktionieren.

### Folie 4 — Globale Variablen

[Folie 4 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=4)

#include \<stdio.h\>

float global = 0.5050;

void triple(void) {

global \*= 3; }

int main(void) {

triple(); printf("%f\\n", global); }

Globale Variablen werden außerhalb aller Funktionen deklariert.

Jede Funktion kann auf globale Variablen zugreifen.

#### Transkript

**[Video 01:55–02:21](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=115)**

Sie sind nur innerhalb der Funktion zugänglich, in der sie deklariert wurden. Es gibt aber auch globale Variablen. Wenn eine Variable außerhalb aller Funktionen deklariert wird, kann jede Funktion darauf zugreifen. In diesem Beispiel habe ich eine globale Variablen-Deklaration grün hervorgehoben. Die Variable heißt global. Um es besonders deutlich zu machen, sie ist vom Typ float und ihr wird der Wert 0,5050 zugewiesen.

**[Video 02:21–02:46](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=141)**

Sie können sehen, dass sowohl in main als auch in triple auf global zugegriffen werden kann. Wenn wir das Programm wie angegeben durchlaufen, ruft main zuerst triple auf. Triple multipliziert global mit drei, wodurch sich der Wert auf etwa 1,51 ändert. Anschließend gibt main den Wert von global aus. Das bedeutet, main wird nicht 0,5050 ausgeben, sondern global mal drei.

**[Video 02:46–03:11](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=166)**

Also ungefähr 1,51. Sie müssen also vorsichtig sein, wenn Sie mit globalen Variablen arbeiten. Obwohl sie sehr flexibel sind und Informationen überall verfügbar machen, kann es dabei zu überraschenden Effekten kommen, wenn eine Funktion den Wert einer Variablen ändert, Sie das aber übersehen haben. Daher sagt man ja auch, dass man auf globale Variablen möglichst verzichten soll. Gibt es denn vielleicht trotzdem Situationen, in denen globale Variablen nützlich sind? Ja.

**[Video 03:11–03:46](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=191)**

Globale Variablen können in bestimmten Situationen nützlich sein, zum Beispiel für Konstanten oder Konfigurationswerte, die im gesamten Programm verwendet werden. Allerdings sollten sie mit Vorsicht eingesetzt werden, da sie, wie gesagt, zu schwer nachvollziehbaren Fehlern führen können. In den meisten Fällen ist es besser, Daten explizit zwischen Funktionen zu übergeben.

### Folie 5 — Übergabe „als Wert“

[Folie 5 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=5)

Lokale Variablen werden in C meist „als Wert“ übergeben. (Zumindest die, die wir bisher kennengelernt haben.)

Dabei erhält die aufgerufene Funktion („callee“) eine Kopie der übergebenen Variable.

Die Variable im aufrufenden Code („caller“) bleibt unverändert (es sei denn, sie wird mit dem Rückgabewert der Funktion überschrieben).

#### Transkript

**[Video 03:11–03:46](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=191)**

Warum macht es einen Unterschied, ob man globale Variablen nutzt oder Werte zwischen Funktionen übergibt? Nun, in C werden lokale Variablen bei Funktionsaufrufen üblicherweise als Wert übergeben. Die Konsequenz davon ist, dass die Variable im aufrufenden Code unverändert bleibt. Es sei denn, sie wird absichtlich überschrieben.

**[Video 03:46–04:16](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=226)**

Da haben wir es wieder, typisch für technische Vorträge. Du erwähnst en passant als Wert übergeben und gehst davon aus, dass alle wissen, was das bedeutet. Du rauschst darüber hinweg und denkst, die Aussage hilft beim Verständnis, während sie tatsächlich bei einem Teil des Publikums Verwirrung stiftet. An diesem Punkt verlierst du sie. Das nennt man manchmal auch den Curse of Knowledge, also den Fluch des Wissens. Du solltest als Wert übergeben hier echt noch einmal erklären. Die meisten Studierenden werden nicht verstehen, was das bedeutet.

**[Video 04:16–04:46](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=256)**

Du hast völlig recht, Entschuldigung. Lass es mich erklären. Als Wert übergeben bedeutet, dass wir der Funktion eine Kopie des Wertes geben. Im Gegensatz zur Übergabe einer Adresse oder eines Zeigers, bei der Stopp, Stopp, Stopp. Siehst du, du machst es schon wieder. Du versuchst, etwas zu erklären, indem du es mit etwas anderem vergleichst, das möglicherweise noch gar nicht bekannt ist. Adressen und Zeiger haben wir doch noch gar nicht behandelt. Versuche es doch mal mit einem Alltagsbeispiel. Na gut, lass es mich anders versuchen. Stell dir vor, du hast einen Schrank mit vielen Schubladen, die nummeriert sind.

**[Video 04:46–05:19](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=286)**

In jeder Schublade liegt ein Zettel mit einer Zahl darauf. Wenn wir eine Variable als Wert übergeben, ist das so, als würden wir den Wert vom Zettel abschreiben und auf einen neuen Zettel schreiben, den wir der Funktion übergeben. Die Funktion kann mit dieser Kopie machen, was sie will, aber der ursprüngliche Zettel in der Schublade, also die ursprüngliche Variable, bleibt unverändert. Würden wir hingegen die Adresse übergeben, was wir hier nicht tun, wäre das so, als würden wir der Funktion die Nummer der Schublade verraten. Die Funktion könnte dann die Schublade öffnen, den Zettel herausnehmen, den Wert darauf ändern und den Zettel wieder in die Schublade zurücklegen.

**[Video 05:19–05:54](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=319)**

Dann hätte sich die Variable geändert. Schon besser. Die Übergabe von Adressen behandeln wir erst später. Weiter. Stimmt. Schauen wir uns ein Beispiel an, das zeigt, wie die Übergabe als Wert funktioniert.

### Folie 6 — Übergabe

[Folie 6 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=6)

int triple(int x) {

als Wert

return x \*= 3; }

int main(void) {

int foo = 4; triple(foo); }

Kein Effekt auf foo in main().

x in triple() ist eine Kopie von foo.

#### Transkript

**[Video 05:19–05:54](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=319)**

Der Übersichtlichkeit halber habe ich die Funktionsdeklarationen hier weggelassen. In diesem Code sehen wir, dass die Variable foo in der Funktion main keinen Effekt erfährt. Wir haben int foo gleich vier, dann rufen wir triple foo auf. In der Funktion triple multiplizieren wir x mit drei und geben das Ergebnis zurück. Aber Achtung: Obwohl wir x in triple verändern, hat das keine Auswirkung auf foo in main. Das liegt daran,

**[Video 05:54–06:25](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=354)**

Dass x eine Kopie von foo ist, nicht foo selbst. Wenn wir nach diesem Funktionsaufruf den Wert von foo in main ausgeben würden, wäre er immer noch vier, nicht zwölf.

### Folie 7 — Übergabe

[Folie 7 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=7)

int triple(int x) {

als Wert

return x \*= 3; }

int main(void) {

int foo = 4; foo = triple(foo); }

foo in main() wird überschrieben.

Der Rückgabewert von triple() wird der Variable foo zugewiesen.

#### Transkript

**[Video 05:54–06:25](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=354)**

Das ist ein gutes Beispiel dafür, wie die Übergabe als Wert funktioniert. Es zeigt auch, warum es wichtig ist, den Rückgabewert einer Funktion zu verwenden, wenn man das Ergebnis einer Berechnung speichern möchte. Genau. Im nächsten Beispiel werden wir sehen, wie wir den Wert tatsächlich ändern können. Hier sehen wir, wie wir foo tatsächlich überschreiben können. Die Funktionsdeklarationen habe ich wieder weggelassen.

**[Video 06:25–06:51](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=385)**

In diesem Beispiel wird foo tatsächlich geändert. Siehst du den Unterschied zum vorherigen Beispiel? Wir haben wieder int foo gleich vier, aber dieses Mal weisen wir das Ergebnis von triple foo der Variable foo zu. Die Funktion triple multipliziert x mit drei und gibt das Ergebnis zurück. Durch die Zuweisung foo ist gleich triple foo wird der Rückgabewert von triple, also zwölf, der Variable foo in main zugewiesen. Wenn wir nach diesem Funktionsaufruf den Wert von foo in main ausgeben würden, wäre er jetzt zwölf, nicht mehr vier.

**[Video 06:51–07:20](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=411)**

Dies zeigt, wie wir den Wert einer Variable ändern können, auch wenn wir sie als Wert übergeben.

### Folie 8 — Gleiche Namen

[Folie 8 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=8)

Jede Funktion hat ihren eigenen Geltungsbereich für lokale Variablen.

In verschiedenen Funktionen können Variablen mit den gleichen Namen verwendet werden.

Dies kann zu Verwirrung führen.

#### Transkript

**[Video 06:51–07:20](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=411)**

Der Schlüssel liegt darin, den Rückgabewert der Funktion zu verwenden, um ihn der ursprünglichen Variable zuzuweisen. Knifflig wird es, wenn der gleiche Variablenname in mehreren Funktionen auftaucht. Das ist durchaus erlaubt, solange die Variablen in verschiedenen Scopes existieren. Betrachten wir ein Beispiel, das zeigt, wie verwirrend das sein kann. Nehmen Sie sich einen Moment Zeit, um den Code auf der nächsten Folie zu analysieren. Versuchen Sie herauszufinden, was am Ende des Programms ausgegeben wird.

**[Video 07:20–07:54](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=440)**

Hier ist das Programm. Am besten halten Sie nun das Video an und überlegen, was hier passiert. Denken Sie daran: Jede Funktion hat ihren eigenen Geltungsbereich für lokale Variablen. Das bedeutet, dass Variablen mit dem gleichen Namen in verschiedenen Funktionen tatsächlich unterschiedliche Variablen sind, auch wenn sie den gleichen Namen tragen.

### Folie 9 — Gleiche

[Folie 9 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=9)

int increment(int x) {

Namen

x++; return x; }

int main(void) {

int x = 1; int y; y = increment(x); printf("x is %i, y is %i\\n", x, y); }

x in main() und x in increment() sind unterschiedliche Variablen.

y erhält den Rückgabewert von increment().

#### Transkript

**[Video 07:20–07:54](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=440)**

Also: In der Main-Funktion initialisieren wir x mit dem Wert eins. Dann deklarieren wir eine Variable y. Anschließend rufen wir increment(x) auf und weisen das Ergebnis y zu. In der increment-Funktion erhöhen wir den Wert von x um eins und geben diesen Wert zurück. Die entscheidende Frage ist, was wird am Ende ausgegeben?

**[Video 07:54–08:22](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=474)**

Um das zu verstehen, müssen wir uns bewusst machen, dass das x in main und das x in increment zwei verschiedene Variablen sind. Sie existieren in unterschiedlichen Geltungsbereichen. Wenn wir increment x aufrufen, wird eine Kopie des Wertes von x aus main an die Funktion increment übergeben. In der Funktion increment wird dieser Wert erhöht und zurückgegeben. Aber das x in main bleibt unverändert. Der zurückgegebene Wert, also zwei, wird y zugewiesen. Also, wenn wir die printf-Anweisung ausführen,

**[Video 08:22–08:48](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=502)**

Wird x ist eins, y ist zwei ausgegeben. Dieses Beispiel zeigt, wie wichtig es ist, den Geltungsbereich von Variablen zu verstehen, besonders wenn gleiche Namen in verschiedenen Funktionen verwendet werden. Um den Geltungsbereich noch deutlicher zu machen, habe ich den Code etwas modifiziert. Ich habe jede Instanz von x, die lokal zu main ist, mit einem kleinen m als Index markiert und jede Instanz von x, die lokal zu increment ist, habe ich mit einem kleinen i als Index gekennzeichnet.

### Folie 10 — Gleiche

[Folie 10 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=10)

int increment(int xi) {

Namen

xi++; return xi; }

int main(void) {

int xm = 1; int ym; ym = increment(xm); printf("x is %i, y is %i\\n", xm, ym); }

xm in main() und xi in increment() sind unterschiedliche Variablen.

ym erhält den Rückgabewert von increment().

#### Transkript

**[Video 08:48–09:19](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=528)**

Dies ist natürlich kein gültiger Code, aber es hilft uns visuell zu verstehen, was tatsächlich passiert. xm sind die Variablen, die lokal zu main sind. xi sind die Variablen, die lokal zur Funktion increment sind. Wenn wir das Programm so betrachten, wird klarer, dass xm und xi tatsächlich zwei verschiedene Variablen sind, auch wenn sie den gleichen Namen x haben. Wenn wir die Funktion increment mit xm aufrufen, wird der Wert von xm kopiert und an xi übergeben. xi wird dann erhöht und zurückgegeben, aber xm bleibt unverändert.

### Folie 11 — Gleiche

[Folie 11 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=11)

int increment(int xi) {

Namen

xi++; return xi; }

int main(void) {

int xm = 1; int ym; ym = increment(xm); printf("x is %i, y is %i\\n", xm, ym); }

Die Ausgabe ist daher:  x is 1, y is 2

#### Transkript

**[Video 09:19–09:50](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=559)**

Das verdeutlicht noch einmal, warum die Ausgabe x ist eins, y ist zwei lautet. Die Variable xm behält ihren ursprünglichen Wert von eins, während y den erhöhten Wert von xi, also zwei, zugewiesen bekommt. Diese Art der Visualisierung kann sehr hilfreich sein, um den Geltungsbereich von Variablen zu verstehen, besonders wenn man anfängt, mit Funktionen und verschiedenen Geltungsbereichen zu arbeiten.

### Folie 12

[Folie 12 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=12)

F1:

Kann es innerhalb eines Programms mehrere Variablen mit dem gleichen Namen geben?

F2:

Kann es innerhalb eines Programms mehrere globale Variablen mit dem gleichen Namen geben?

F3:

Kann es lokale und globale Variablen mit dem gleichen Namen geben?

#### Transkript

**[Video 09:19–09:50](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=559)**

Das Beispiel veranschaulicht, wie sich der Geltungsbereich von Variablen auswirkt. Es zeigt auch, wie die Übergabe von Variablen als Wert funktioniert.

**[Video 09:50–10:23](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=590)**

Und wie Rückgabewerte von Funktionen genutzt werden können. Es kann anfangs verwirrend sein, besonders wenn der gleiche Variablenname in verschiedenen Funktionen verwendet wird. Aber mit etwas Übung werden Sie in der Lage sein, solche Situationen zu analysieren. Oh, ich bekomme gerade eine Frage aus dem Publikum. Moment. Also die Frage lautet: Kann es innerhalb eines Programms mehrere Variablen mit dem gleichen Namen geben? Kann es innerhalb eines Programms mehrere globale Variablen mit dem gleichen Namen geben? Und

**[Video 10:23–10:51](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=623)**

Kann es lokale und globale Variablen mit dem gleichen Namen geben? Kannst du das vielleicht für den Herrn im Publikum erklären? Natürlich, das sind sehr gute Fragen. Lass uns sie der Reihe nach beantworten. Kann es innerhalb eines Programms mehrere Variablen mit dem gleichen Namen geben? Ja, das ist möglich. Wie wir in unseren Beispielen gesehen haben, können verschiedene Funktionen lokale Variablen mit dem gleichen Namen haben. Diese sind dann in ihrem jeweiligen Funktionsbereich gültig und voneinander unabhängig.

**[Video 10:51–11:21](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=651)**

Kann es innerhalb eines Programms mehrere globale Variablen mit dem gleichen Namen geben? Nein, das ist nicht möglich. Globale Variablen sind im gesamten Programm sichtbar und zugänglich. Daher muss jede globale Variable einen eindeutigen Namen haben. Wenn man versucht, zwei globale Variablen mit dem gleichen Namen zu deklarieren, wird der Compiler einen Fehler melden. Kann es lokale und globale Variablen mit dem gleichen Namen geben? Ja, das ist möglich, aber es kann zu Verwirrung führen und wird daher oft als schlechter Programmierstil betrachtet.

**[Video 11:21–11:56](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=681)**

Wenn innerhalb einer Funktion eine lokale Variable den gleichen Namen wie eine globale Variable hat, verdeckt die lokale Variable die globale innerhalb dieser Funktion. Das bedeutet, dass Zugriffe auf diesen Namen innerhalb der Funktion sich auf die lokale Variable beziehen, nicht auf die globale. Außerhalb dieser Funktion bezieht sich der Name weiterhin auf die globale Variable. Es ist wichtig zu beachten, dass solche Namensüberschneidungen, obwohl technisch möglich, oft zu Verwirrung und schwer zu findenden Fehlern führen können. Es ist generell eine gute Praxis, eindeutige Namen für Variablen zu verwenden, unabhängig von ihrem Geltungsbereich.

### Folie 13

[Folie 13 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=13)

EX T RA S I N 3 M IN UT E N FRAGEN – ANTWORTEN – RÄTSEL UND KURZE ZUSAMMENFASSUNG

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*

### Folie 14

[Folie 14 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=14)

F4:

Ist der Geltungsbereich einer Variablen immer die gesamte Funktion oder beginnt er erst ab dem Punkt, an dem die Variable in der Funktion deklariert wird?

#### Transkript

**[Video 11:56–12:26](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=716)**

Super, danke für die ausführliche Erklärung. Das hilft sicherlich einige der Feinheiten des Geltungsbereichs von Variablen zu verstehen. Vielen Dank für diese Frage. Beantwortet das Ihre Frage vollständig? Ah, Sie haben noch eine Anschlussfrage. Oh Moment, ich glaube, das ist etwas für unsere drei Extraminuten. Sind Sie noch da? Was wollten Sie denn noch wissen? Ah, Sie fragen, ob der Geltungsbereich einer Variable immer der gesamten Funktion entspricht oder ob er erst ab

**[Video 12:26–12:54](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=746)**

Dem Punkt gilt, an dem die Variable deklariert wird. Das ist tatsächlich etwas komplizierter, als es zunächst scheint. Aber wir werden versuchen, das gut verständlich zu erklären. Also könntest du bitte das erklären? Vielleicht wäre es hilfreich, wenn du die Situation mit zwei aufeinanderfolgenden For-Schleifen innerhalb einer Funktion erläuterst, die beide int i gleich null als Iterator verwenden. Und dann könntest du auch erklären, was passiert, wenn wir denselben Variablennamen außerhalb dieser For-Schleifen

**[Video 12:54–13:23](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=774)**

In der Funktion noch mal verwenden. Natürlich, das ist eine ausgezeichnete Frage, die uns tiefer in das Konzept des Geltungsbereichs führt. In C gilt der Geltungsbereich einer Variablen tatsächlich ab dem Punkt ihrer Deklaration bis zum Ende des Blocks, in dem sie deklariert wurde. Ein Block wird durch geschweifte Klammern definiert. Lassen Sie uns das anhand eines Beispiels mit zwei for-Schleifen verdeutlichen. In diesem Beispiel haben wir eine Variable x, die im gesamten Funktionsbereich gültig ist. Zwei for-Schleifen, die jeweils ihre eigene Variable i deklarieren.

**[Video 13:23–13:51](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=803)**

Die zwei Variablen i sind nur innerhalb ihrer jeweiligen Schleife gültig. Eine weitere Variable i außerhalb der Schleifen, die einen anderen Geltungsbereich hat als die Variablen i in den Schleifen. Jede dieser i-Variablen hat ihren eigenen Geltungsbereich und eigenen Wert. Sie verdecken sich gegenseitig nicht, da sie in verschiedenen Blöcken deklariert wurden. Dies zeigt, dass der Geltungsbereich einer Variablen in C nicht immer der gesamten Funktion entspricht, sondern vom Punkt ihrer Deklaration bis zum Ende des umschließenden Blocks reicht.

**[Video 13:51–14:20](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=831)**

Es ist vielleicht noch gut zu wissen, dass die späte Variablendeklaration innerhalb von Blöcken nur in C99 und späteren Standards möglich ist. Früher musste man Variablen immer ganz am Anfang eines Blocks deklarieren. Danke für die detaillierte Erklärung. Ich hoffe, das beantwortet Ihre Frage vollständig. Oder? Okay, wenn nicht, zögern Sie bitte nicht, weitere Fragen zu stellen. Während du das jetzt erklärt hast, habe ich eine Folie vorbereitet, die den Studierenden helfen soll, ihr Verständnis von lokalen und globalen Variablen zu überprüfen.

**[Video 14:20–14:55](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=860)**

Hier ist der Code. Ah, das ist ein nettes Beispiel. Am besten versuchen die Studierenden wieder die Ausgabe dieses Programms vorherzusagen, bevor sie es ausführen. Es ist eine großartige Übung, um ihr Verständnis von globalen und lokalen Variablen sowie deren Geltungsbereichen zu überprüfen. Haben wir noch etwas? Ne, für heute reicht das. Okay, dann noch einmal vielen Dank an den Herrn mit der Zuschauerfrage. Ich hoffe, die Erklärungen waren hilfreich und Moment mal. Apropos Zuschauer, sag mal, hast du wirklich mit jemandem während der Aufnahme gesprochen oder hast du das nur vorgetäuscht, um mich auf die Probe zu stellen?

**[Video 14:55–15:24](https://www.youtube.com/watch?v=bZcHjHxt5-c&t=895)**

Wer weiß? Aber du hast am Anfang doch gesagt, du seist allein im Raum. Das würde ja bedeuten: Moment mal, jetzt bin ich völlig verwirrt. Und damit beenden wir heute das Thema Variablen-Geltungsbereiche. Denken Sie daran: In der Programmierung wie im Leben. Manchmal ist die Funktion eben nicht immer das, was sie zu sein scheint, aber sie erfüllt immer ihren Zweck. Vielen Dank fürs Zuschauen. Dies war Inf-Einf-B.

### Folie 15 — void example\_function() {

[Folie 15 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=15)

int x = 5; // x in ganzer Funktions gültig

for (int i = 0; i \< 3; i++) {

// i ist nur in dieser Schleife gültig. printf("Erste Schleife: i = %d, x = %d\\n", i, x); } // Hier ist i nicht mehr gültig.

for (int i = 0; i \< 3; i++) {

// Neue Variable i, nur in dieser Schleife gültig. printf("Zweite Schleife: i = %d, x = %d\\n", i, x); } // Hier ist i wieder nicht mehr gültig

int i = 10; // Neue Variable i, gültig bis Funktionsende printf("Außerhalb: i = %d, x = %d\\n", i, x); }

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*

### Folie 16 — #include \<stdio.h\>

[Folie 16 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=16)

int g = 5;

void changeGlobalOne(int l) {

l = 10; }

int main() {

void changeGlobalTwo(int g) {

printf("%i\\n", g); changeGlobalOne(g); printf("%i\\n", g); changeGlobalTwo(g); printf("%i\\n", g); changeGlobalThree(); printf("%i\\n", g); return 0; }

g = 10; }

void changeGlobalThree() {

g = 10; }

#### Transkript

*Kein Transkriptabschnitt eindeutig dieser Folie zugeordnet. Möglicherweise eine Aufbau-/Grafikfolie oder eine Abweichung zwischen PDF und Video.*

### Folie 17 — Der Geltungsbereich einer Variablen reicht vom Punkt

[Folie 17 als PDF](https://inf.zone/download/lectures/2-arrays/2.2-scope.pdf#page=17)

Lokale Variablen: nur innerhalb der Funktion

ihrer Deklaration bis zum

zugänglich, in der sie

Ende des Blocks {...}, in dem sie deklariert wurde

deklariert wurden

Gleiche Variablennamen können in verschiedenen

Globale Variablen: werden außerhalb aller Funktionen

Funktionen verwendet werden – es handelt sich dann um unterschiedliche

deklariert und sind im

gesamten Programm

zugänglich

Variablen

Bei der Übergabe als Wert

Eine lokale Variable mit gleichem Namen verdeckt

erhält eine Funktion nur eine Kopie der Variable – die Original-Variable bleibt

eine globale Variable

innerhalb ihres Geltungsbereichs.

unverändert.

> 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.*