Herzlich willkommen zur dritten Vorlesung jetzt. Wir hatten uns letzte Woche mit noch so ein paar Themen

im Zusammenhang mit Funktionen dann vor allem um das Thema Software Design gekümmert und uns damit

beschäftigt, ganz kurz noch mal so die wesentlichen Punkte, um die es ging. Also es ging um dieses Thema

Modularisierung, wo ich ja vor allem herausheben wollte, so im Mittelpunkt das Problem, dass bei

dieser Art der prozeduralen Programmierung oder imperativen Programmierung im Gegensatz zur

objektureinheitlichen Programmierung eine Strukturierung nur in Bezug auf die Tätigkeiten,

also was ist im Rahmen des Programms zu tun, erfolgt. Das sind die Funktionen letztendlich,

die für die Teiltätigkeiten stehen und die Daten kann man natürlich strukturieren, aber die Struktur

der Daten ist erstmal unabhängig davon, im Gegensatz eben zur objektorientierten Programmierung,

wo wir eben diese Einheiten haben, die Objekte, bei denen wir eine Kapselung haben der Daten und der

Operationen auf diesen Daten. So, wenn man das Ganze dann ungeschickt angeht, dann kommt irgendwie

sowas in diesem Stil hierbei raus. Ich habe diese blaue Wolke von Daten, sehr viele Daten und eine

Menge von Funktionen, die da mehr oder weniger wild drauf arbeiten. Solange das also eigentlich

am meisten klein und überschaubar ist, die Software, ist das sicherlich alles kein Problem,

wenn wir aber eben über ein paar Hunderttausend Zeilen Code oder ein paar Millionen Zeilen Code

reden und dieser Code produziert von Entwicklungsgruppen quer über die Welt vielleicht

auch noch verteilt, hat das Ganze über Jahrzehnte hinweg gewachsen, dann haben wir natürlich ein

Problem, wenn wir so strukturieren. Und dann ist natürlich die Frage, wie können wir in der

Programmiersprache wie C dieses Problem lösen. Die Lösung ist Modularisierung, schaut ein bisschen

ähnlich aus wie Objektorientierung, wir führen eine Kapselung ein, haben Funktionen, die auf

Daten operieren und eben über Modulgrenzen hinweg hat man keinen Zugriff auf Daten. Dann hatte ich

erzählt, wie man das eben in C macht, indem man eben ein Modul letztendlich ist, eine Punkt C Datei und

man bindet diese Punkt C Datei und die übersetzten Punkt C Datei hinterher zusammen, also beim

Übersetzen einer Punkt C Datei entsteht so eine Punkt O Datei und die kann man dann zusammenbinden

und so entsteht das Gesamtprogramm. So, dann hatten wir über Götigkeit von Namen gesprochen,

diese Stufen global im gesamten Programm, das sind also quasi die externen Funktionen und oder

globalen Funktionen und Variablen. Bei Variablen hatte ich darauf hingewiesen, das sollte man nicht

machen, bei Funktionen sind es im Endeffekt die Schnittstellen zwischen den Modulen, die dadurch

entstehen. Dann haben wir global in einem Modul, also auch über Funktionsgrenzen hinweg, aber eben

auf das Modul beschränkt und damit haben wir im Prinzip exakt das, was wir hier haben, das wären

solche Modul globalen Variablen, sie sind aus allen Funktionen des Moduls erreichbar, aber sie sind

eben nicht aus den Funktionen anderer Module erreichbar. Das sind dann diese Daten, die Variablen,

bei denen man die man global definiert, aber bei denen man das Schlüsselwort Static davor schreibt.

Gut und dann innerhalb einer Funktion oder innerhalb eines Blocks eben lokal begrenzte Variablen. Was die

Götigkeit von Namen angeht, ist eigentlich eine ganz wichtige Sache, man sollte sehen, dass Daten

immer quasi so wenig wie möglich sichtbar sind. So weit wie nötig natürlich, aber eben man sollte

die Sichtbarkeit so stark einschränken, wie es irgendwie geht, denn damit verhindert man eigentlich

schon alleine durch die Prüfung der Programmiersprache, dass von Stellen zugegriffen wird,

von denen nicht zugegriffen werden sollte. Das war also lange Zeit doch sehr sehr weit verbreitet,

dass man so irgendwo standardmäßig alles einfach global definiert hat und man hatte

natürlich dann leichtes Spiel, man konnte von überall dann drauf zugreifen, aber man zahlt

letztlich einen hohen Preis dafür, nämlich was die letztendlich die Wartbarkeit von der Software

angeht, weil man halt irgendwann eben doch sehr leicht den Überblick verliert, welche Funktionen

jetzt wirklich welche Daten benutzen. So das waren die globalen Variablen, darüber hatten wir

gesprochen. Die globalen Funktionen eben die Schnittstellen zwischen den Modulen und dann

eben die Einschränkung der Götigkeit auf ein Modul mit diesem Schlüsselwort Static.

Ja und dann die lokalen Variablen. Und zwar am Schluss kommt eben genau dieses Bild bei

heraus und das war der Abschluss der letzten Vorlesung. Hier also nochmal die globalen

Variablen hier ganz oben, das sind also die Variablen, die man tunlichst nicht verwenden

sollte. Dann die blauen Kreise innerhalb der Module, das sind die globalen Static-Variablen,