Informatik II Grundlagen der Programmierung Programmieren in C Funktionen, Adressen, Zeiger...

Informatik IIGrundlagen der Programmierung

Programmieren in C

Funktionen, Adressen, Zeiger

Hochschule Fulda – FB ET

Sommersemester 2014

http://c-et.rz.hs-fulda.de

Peter Klingebiel, HS Fulda, DVZ

Programmieren in C - Peter Klingebiel - HS Fulda - DVZ 2

Was können wir jetzt? 1



• einfache Programme bestehend aus main()– und einigen/mehreren/vielen Zeilen C-Code …– mit überschaubaren Aufgabenstellungen …– und überschaubarer Komplexität …– auch wenn schon komplexere Programme hier

und dort schon einmal gezeigt wurden

• doch meist sind die Aufgabenstellungen und damit auch die erforderlichen Programme sehr viel größer und sehr viel komplexer


Was ist erforderlich? 1

• hohe Komplexität Komplexität reduzieren

• große Programme / Aufgaben in kleinere Programmteile / Teilaufgaben zerlegen

• oft gleiche / ähnliche Aufgabenstellung Wiederverwendbarkeit von Programm- teilen ermöglichen

Konzept von Unterprogrammen / Sub- routinen / Prozeduren / Funktionen



• Beispiel: Hausbau in Fertigbauweise

http://www.youtube.com/watch?v=81_oOjD6NY0&feature=player_detailpage



• C bietet das Konzept von Funktionen• eine Funktion realisiert eine fest umrissene

Aufgabe bzw. Teilaufgabe• Das hat viele Vorteile: kleinere Teile

– sind einfacher zu verstehen/zu programmieren– können einfacher verändert werden– können einfacher überprüft/getestet werden– sind parallel erstellbar– sind wiederverwendbar– erfüllen eine klar definierte Aufgabe („Funktion“)



• größeres Problem in kleinere Teile zerlegt• Erinnerung: Adam Ries123 * 45 123 * 4 * 10 + 123 * 5aus komplexer Multiplikation wird einfache Multiplikation und einfache Addition

• Wir kennen und verwenden Funktionen– main(), printf(), scanf(), sqrt(), …

• sind nicht Teil der Sprache, sondern definiert in der C-Standardbibliothek

• wir können eigene Funktionen schreiben


Funktionen 1

• Funktionen sind Programmteile (Blöcke) mit einem Typ, einem Namen, ggfs. Parametern (Eingangsdaten) und ggfs. Rückgabewert (Ausgangsdaten)

• elementare Bausteine für Programme– gliedern umfangreiche Aufgaben in kleinere

Komponenten

– reduzieren Komplexität

– Wiederverwendung von Komponenten

– verbergen Details der Implementierung vor anderen Programmteilen (black box)

Funktionen 2

Funktionen 3

Funktionen 4

• C-Programm Daten werden durch die Mühlen von Funktionen geschoben

Funktionen 5


Funktionen 6

• dienen der Abstraktion• Name und Parameter abstrahieren

– vom tatsächlichen Programmstück– von Darstellung und Verwendung der Daten

• Wiederverwendung– mehrfach benötigte Programmstücke werden

einmal erstellt und können durch Angabe des Funktionsnamens aufgerufen werden

– schrittweise Abstraktion möglichEntwurf top-down oder bottom-up


Funktionen 7

• Beispiel: Summenbildung summe(a:b)int summe(int a, int b){ int sum; int i; for(sum = 0, i = a; i <= b; i++) sum = sum + i; return(sum);}

• Beliebig immer wieder verwendbar:s1 = summe(20, 50);s2 = summe(2, 120);


Funktionsdefinition 1

• Schnittstelle (Typ, Name, Parameterliste)• Typ

– Datentyp, der von Funktion zurückgeliefert wird

– kann ein beliebiger Datentyp sein– void kein Rückgabewert ( Prozedur)

• Name – Bezeichner kann nach den Regeln für Identifier

beliebig gewählt sein, insb. keine Schlüsselworte

• Parameterliste– Typ und Name der Parameter

– kann leer sein, dann () oder (void)



• Syntaxdiagramm

• Beispielint summe(int a, int b){ int sum; ... return(sum);}



• Formale Parameter

• beliebiger Typ, beliebiger Bezeichner• formale Parameter Platzhalter für aktuelle

an Funktion übergebene Parameter• in Funktion wie vorbelegte lokale Variable



• Beliebiger Block mit {} geklammert• Zusätzliche Anweisung return(ausdruck)

Rückkehr aus der Funktion• Klammern bei return können entfallen• Bei void-Funktion: nur return• Nach Rückkehr aus Funktion Programm

wird direkt nach Funktionsaufruf fortgesetzt• Typ von Ausdruck und Funktion müssen

übereinstimmen



• Beispiel: Funktion summe()• Funktionskopf: Typ, Name, Parameter

int summe(int a, int b)

• Funktionskörper (body), Block{ int sum; // lokale Variable int i; // lokale Variable for(sum = 0, i = a; i <= b; i++) sum = sum + i; return(sum);}

• Rückgabe int sum return(sum);


Funktionsaufruf 1

• Funktionen werden aufgerufen• im Programm steht

– Name der Funktion

– Parameter (Variable/Ausdrücke) in Klammern

– ggfs. eine Zuweisung des Funktionswerts

• von aufrufender Stelle: Sprung in Funktion • Beispiel:

int s1, s2;...s1 = summe(20, 50);s2 = summe(2, 120);


Funktionsaufruf 2

• Syntaxdiagramm:

– jeder Funktionsaufruf ist ein Ausdruck– void-Funktionen können keine Teilausdrücke

sein wie Prozedur in anderen Sprachen


Funktionsaufruf 3

• die Ausdrücke in der Parameterliste werden vor dem Eintritt / Sprung in die Funktion ausgewertet aktuelle Parameter

• Anzahl und Typen der Ausdrücke der aktuellen Parameter müssen mit denen der formalen Parameter in der Definition der Funktion übereinstimmen

• die Auswertungsreihenfolge der Parameter-ausdrücke ist nicht festgelegt


Funktionsaufruf 4

• Beispiel


Funktionsaufruf 5

• vor Programmstart


Funktionsaufruf 6

• Programmstart: Speicherreservierung


Funktionsaufruf 7

• Kopieren des aktuellen Parameters a


Funktionsaufruf 8

• Aufruf der Funktion quadrat()


Funktionsaufruf 9

• In Funktion quadrat(): berechnen


Funktionsaufruf 10

• Returnwert liefern in a kopieren


Funktionsaufruf 11

• Rückkehr aus quadrat() nach main()


Funktionsaufruf 12

• Nach Rückkehr


Funktionsaufruf 13


Funktionsaufruf 14


Funktionsaufruf 15


Funktionsaufruf 16


Exkurs: Adressen / Pointer 1

• Noch einmal:a = quadrat(a);

• Wert des aktuellen Parameters a wird vor Aufruf von quadrat(a) in den Speicherraum der Funktion quadrat kopiert

• In der Funktion quadrat(int b) erhält der formale Parameter b den Wert von a und kann damit rechnen und ihn verändern

• der Wert von a bzw. a bleibt unverändert• erst die Zuweisung a = quadrat(a); verändert

im Beispiel den Wert von a



• Frage: Wie kann der Wert eines Funktions-parameters verändert werden?

• Beispiel: void swap(int i, int j){ int t; // temporaere Variable t = i; // i zwischenspeichern i = j; // j auf i zuweisen j = t; // t auf j zuweisen}

• verändert der Aufruf swap(a, b) tatsächlich

den Wert der aktuellen Parameter a und b ?



• NEIN, da die aktuellen Parameter a und b mit ihrem Wert in die Funktion kopiert werden

• Veränderungen des Werts innerhalb einer Funktion haben keine Auswirkungen auf den Wert von aktuellen Parametern!



• Die Lösung: Pointer oder Zeiger void swap(int *i, int *j){ int t; // temporaere Variable t = *i; // *i zwischenspeichern *i = *j; // *j auf *i zuweisen *j = t; // t auf *j zuweisen}

• Aufruf: swap(&a, &b);



• Das kennen wir schon!• Beispiel: Einlesen von Werten mit scanf()scanf(%d, &zahl);

• Parameter werden mit dem Adressoperator & versehen übergeben: &zahl

• in der Funktion: Pointer *z enthält Adresse / Speicherort des Parameters und kann so den Wert des Parameters zahl verändern

Call by value oder Call by reference



• Kennen wir auch schon: Wie C speichert



• Speicherplatz von a, b,c Orte im Speicher



• Zuweisung a=4; Wert an Speicherstelle



• Wdh: Jede Variable hat einen Speicherort,d.h. eine Adresse im Hauptspeicher

• Zeiger (Pointer) sind Variable, die auf eine andere Variable verweisen, oderexakter: den Speicherort bzw. die Adresse dieser Variablen als Wert haben

• Pointerdefinition: int *ip; int i = 5;

• Adresszuweisung: ip = &i;• Zugriff auf Wert: *ip = *ip + *ip;



• Zugriff auf Variable mit Pointer



• Vor Programmstart



• Programmstart und Aufruf von main()



• Zuweisung i = 5;



• Zuweisung ip = &i;



• Berechnung *ip + *ip;



• Zuweisung *ip = *ip + *ip;



• Danach


Funktionsaufruf und Parameter

• Parameterübergabe als Werte (call by value), z.B. bei printf()

Variable werden als Werte in den Adress-raum der Funktion auf lokale Variable kopiert

• Parameterübergabe als Adresse (call by reference), z.B. bei scanf()

Adressen der Variablen werden in den Adressraum der Funktion kopiert

• in der Funktion: Parameter sind Pointer!


Call by value 1

• Beispiel: Funktionsaufruf cbv


Call by value 2



Call by value 3

• Zuweisung a = 4;


Call by value 4

• Kopie des Parameters a in Funktion


Call by value 5

• Aufruf der Funktion


Call by value 6

• Zuweisung b = b * 2;


Call by value 7

• Rückkehr aus Funktion


Call by value 8

• Variable a unverändert!!!


Call by reference 1

• Beispiel: Funktionsaufruf cbr


Call by reference 2



Call by reference 3

• Wo ist der Unterschied cbv – cbr?


Call by reference 4

• Aufruf: Adresse der Variablen: doit(&a)!!!


Call by reference 5

• In Funktion: *b Zeiger auf Variable!!!


Call by reference 6

• Zuweisung a = 4;


Call by reference 7

• Kopie der Adresse in die Funktion


Call by reference 8

• Aufruf der Funktion


Call by reference 9

• Zuweisung *b = *b * 2;


Call by reference 10

• Rückkehr aus Funktion


Call by reference 11

• So soll es sein: Variable a verändert!!!


Funktionsdeklaration 1

• vor dem Aufruf einer Funktion muss diese dem C-Compiler bekannt sein– Name der Funktion– Typ der Funktion / des Rückgabewerts– Anzahl und Typen der Parameter

• ist die Funktion vor ihrem Aufruf definiert, ist sie dem Compiler bekannt

• andernfalls muss sie bekannt gemacht oder deklariert werden

Prototype



• Beispiel:int power(int, int);oderint power(int b, int e);

• Deklaration erzeugt keinen Code!• Nach der Deklaration kann die Funktion

verwendet dann werden• Compiler kann Name, Typ und Parameter

prüfen erhöht Programmiersicherheit



• Funktionsdefinition (analog zu Variablen!)– erzeugt Code– macht Funktion (Typ, Name, Parameter) bekannt

• Funktionsdeklaration (analog zu Variablen)– macht Funktion (Typ, Name, Parameter) bekannt– vor Verwendung der Funktion

• Oft in Standard- (oder eigenen) Headerfiles– Konvention: Dateiname endet auf .h– #include <file.h> fügt Headerdatei textuell

in Quelltext ein deklarierte Funktionen bekannt


Sichtbarkeit von Funktionen

• Eine C-Quelldatei stellt ein Modul dar (= Übersetzungseinheit)

• in einem Modul definierte Funktionen können in anderen Modulen verwendet werden

• sie sind damit extern sichtbar und werden durch Prototypes bekannt gemacht

• Soll Sichtbarkeit auf das Modul (= Quelldatei) beschränkt werden: static verwenden

• Beispiel: static int localfunc() {…}


Gedächtnis von Funktionen

• lokale Variable werden beim Eintritt in die Funktion im Speicher angelegt und nach Verlassen der Funktion ungültig

• ihre Werte verschwinden!• Abhilfe:

– globale Variable– ungünstig, Nebeneffekte! Vermeiden!– statische Variable in Funktion– Wert bleibt erhalten, sichtbar nur in Funktion– Bsp: static int wert = 1;


Optimierungen

• Rückgabewerte oft direkt als Parameter für Funktionsaufrufe verwendbar– ohne Zwischenspeicherung in Variablen– Beispiel: funa(funb(), func());

• Funktionsaufruf kostet Zeit und Speicherplatz• Funktion kann als inline definiert werden

– Bsp: inline void swap(int i, int j){…}– statt Funktionsaufruf wird Funktionscode eingefügt– nur Empfehlung an den Compiler– gcc setzt Inlining bei Optimierung um (gcc –O)


Rekursion

• bei einem Funktionsaufruf wird ein eigener Speicherbereicht für lokale Variable (und damit auch für Parameter) angelegt

• damit ist möglich, dass eine Funktion sich selbst aufruft Rekursion

• Beispiel: Fakultätsfunktion n! = 1*2*…*nint fakultaet(int n) { if(n == 1) return(1); // Endebedingung else return(n * fakultaet(n – 1));}

elegante Lösungen möglich


Hinweise 1

• zerteilen Sie eine größere Aufgabe in kleinere Teilaufgaben

• führen Sie Funktionen mit lokalen Variablen (einschl. Parametern) ein– vermeiden Sie globale Variable– wählen Sie aufschlussreiche Namen– klarer Zweck!– nicht zu groß! Besser aufteilen in Teilfunktionen!– nutzen Sie static-Funktionen– Deklaration von Prototypen


Hinweise 2

• Definition, Deklaration und Aufruf von Funktionen müssen übereinstimmen– Typ des Funktionswertes– Anzahl, Typ und Reihenfolge der Parameter

• Eine Funktion hat nur einen Rückgabewert• Bei Funktionen mit Rückgabewert immer return als letztes Statement

• Funktionsdefinition ohne Semikolon ;• Funktionsdeklaration/Prototyp mit ;

Informatik II Grundlagen der Programmierung Programmieren in C Funktionen, Adressen, Zeiger...

Documents

Transcript of Informatik II Grundlagen der Programmierung Programmieren in C Funktionen, Adressen, Zeiger...