Funktionen
Beispiel:
int main(){ int geld; geld = 10; verdopple(geld); } void verdopple(int g){ g = 2 * g;
Was passiert beim Aufruf ?
int main(){ int geld; geld = 10; verdopple(geld); } Inhalt wird automatisch kopiert in die Variable g void verdopple(int g){ g = 2 * g; }
konkret:
int main(){ int geld; geld = 10; verdopple(geld); } 10 void verdopple(int g){ g = 2 * g; }
int main(){ int geld; geld = 10; verdopple(geld); } 10 void verdopple(int g){ g = 2 * g; }
int main(){ int geld; geld = 10; verdopple(geld); } 10 void verdopple(int g){ g = 2 * g; }
int main(){ int geld; geld = 10; verdopple(geld); } 10 void verdopple(int g){ g = 2 * g; }
int main(){ int geld; geld = 10; verdopple(geld); } 10 void verdopple(int g){ g = 2 * g; }
int main(){ int geld; geld = 10; verdopple(geld); } 10 void verdopple(int g){ g = 2 * g; }
int main(){ int geld; geld = 10; verdopple(geld); } 10 void verdopple(int g){ g = 2 * g; }
10 int main(){ int geld; geld = 10; verdopple(geld); } Aber: geld = 10 void verdopple(int g){ g = 2 * g; } 20 10
Mit der "Technik", die gerade in dem Beispiel vorgeführt wurde, kann man also keinen Output realisieren.
Deshalb werden wir (neben der "Technik" mit return) im Folgenden eine weitere "Technik" kennen lernen, mit der man einen Output realisieren kann.
Beispiel
Ein Hacker weiß nur, dass Sie durch einen Gewinn insgesamt 100 000 Euro auf irgendeinem Konto haben. Kann er - nur mit diesem Wissen - Sie betrügen?
Nein, da er dadurch noch keinen Zugriff auf das Bankkonto hat.
Welche weitere Angabe benötigt er noch, um überhaupt einen Angriff (über Online-Banking)auf Ihr Bankkonto planen zu können?
Die Kontonummer = Adresse des Bankkontos
Bankkonto besteht also aus: Kontonummer =. Adresse Kontostand = Bankkonto besteht also aus: Kontonummer = Adresse Kontostand = Inhalt (Wert)
Wie erfolgt nun ein Angriff auf Ihr Bankkonto, der den Kontostand um z Wie erfolgt nun ein Angriff auf Ihr Bankkonto, der den Kontostand um z.B. 30000 Euro vermindert ?
Kontostand (Euro) Herr Maier: Kontonummer Kontostand 471108151 100 000 Befehl des Hackers: Inhalt(471108151) = Inhalt(471108151) - 30000
Das bedeutet für uns: Funktion erzeugt Output, indem ihr die Adresse einer Variablen übergeben wird. Die Funktion kann dann über die Adresse den Inhalt ändern.
Beispiel:
int main(){ int geld = 10; int erg; verdopple(geld, &erg); } void verdopple(int g, int *gn){ *gn = 2 * g;
verdopple(geld, &erg); Wert wird automatisch kopiert in die Variable g Wert wird automatisch kopiert in die Variable gn verdopple(g, gn); *gn = 2 * g;
konkret:
verdopple(geld, &erg); } geld 0123 10 erg 0815 ? int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 ? 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; }
verdopple(geld, &erg); } geld 0123 10 erg 0815 ? int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 ? 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; }
verdopple(geld, &erg); } geld 0123 10 erg 0815 ? int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 ? 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; }
verdopple(geld, &erg); } geld 0123 10 erg 0815 ? int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 ? 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; }
verdopple(geld, &erg); } geld 0123 10 erg 0815 ? int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 ? 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; }
verdopple(geld, &erg); } geld 0123 10 erg 0815 ? int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 ? 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; }
verdopple(geld, &erg); } geld 0123 10 erg 0815 ? int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 ? 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; }
verdopple(geld, &erg); } geld 0123 10 erg 0815 ? int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 ? 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; }
verdopple(geld, &erg); } geld 0123 10 erg 0815 ? int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 ? 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; } 0815 10 20
verdopple(geld, &erg); } geld 0123 10 erg 0815 int main(){ int geld = 10; int erg; verdopple(geld, &erg); } Name Adresse Wert geld 0123 10 erg 0815 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; } 0815 10 20
20 int main(){ int geld = 10; int erg; verdopple(geld, &erg); } geld Name Adresse Wert geld 0123 10 erg 0815 20 10 0815 void verdopple(int g, int *gn){ *gn = 2 * g; } 0815 10 20 erg = 20
Weitere Möglichkeit:
Beim Mosten: Man gibt 100 Kg Mostäpfel im Zuber ab und bekommt sie im gleichen Zuber zurück:
Äpfel
Most
Beispiel:
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; }
void verdopple(int *m){ *m = 2 * *m; } 0815 0815 int main(){ int geld = 10; verdopple(&geld); } Adresse Wert geld 0815 10 0815 void verdopple(int *m){ *m = 2 * *m; } 0815 0815 20 10
20 int main(){ int geld = 10; verdopple(&geld); } geld 0815 20 0815 Adresse Wert geld 0815 20 0815 void verdopple(int *m){ *m = 2 * *m; } 0815 0815 20 // geld: 20 10
Welche weitere, schon bekannte Möglichkeit, gibt es noch ? mit return
int main(){ int kohle; int erg; kohle = 10; erg = verdopple(kohle); } int verdopple(int knete){ int viel; viel = 2 * knete; return(viel); }
Wird bei einem Funktionsaufruf die Adresse einer Variablen übergeben, so nennt man dies: call by reference Wird dagegen der Wert einer Variablen (und nicht die Adresse) übergeben, nennt man dies: call by value.
Wir werden Funktionen IMMER nach dem folgenden Schema in einem Programm kommentieren: (siehe Arbeitsblatt)
#include "stdafx.h" #include <stdio.h> int berechne(double a, double b, double *u, double *f); int main(){ double s1; double s2; int erg; double flaeche; double umfang; s1=10; s2=20; erg = berechne(s1, s2, &umfang, &flaeche); if (erg==1) printf("Das Rechteck ist ein Quadrat"); printf("Umfang=%f Fläche=%f erg=%d", umfang, flaeche, erg); } /**************************************************************/ /** **/ /** int berechne(double a, double b, double *u, double *f) **/ /*#************************************************************/ /* Parameter: (i) double a>=0 : eine Seitenlänge des Rechtecks (i) double b>=0 : andere Seitenlänge des Rechtecks (o) double *u: Umfang des Rechtecks (o) double *f: Fläche des Rechtecks Return: (o) 1: Quadrat 2: Rechteck Beschreibung: Berechnet aus den beiden Seitenlängen a und b des Rechtecks den Umfang *u und die Fläche *f und bestimmt außerdem, ob es ein Quadrat oder ein Rechteck ist. */ int berechne(double a, double b, double *u, double *f){ int r; *u=2*(a+b); *f=a*b; if(a==b) r=1; else r=2; return(r);
Eine wichtige Bemerkung:
Eine Funktion ist eine Black Box, die im allgemeinen einen Input benötigt und daraus einen Output erstellt. Aus Sicht eines Kunden soll der Input nicht redundant (überflüssig) sein (wie z.B. runder Kreis, weisser Schnee).
Beispiel:
Es soll die Quersumme einer positiven, ganzen Zahl berechnet werden (z Es soll die Quersumme einer positiven, ganzen Zahl berechnet werden (z.B. von 123: 1+2+3 =6). Als Input genügt die Zahl. Die Angabe der Anzahl der Ziffern von 123 wäre redundant.
Dies soll gefälligst von der Funktion berechnet werden!! D.h. möglichst viel Arbeit an die Funktion abdrücken!! Wenn man einen Urlaub im Hotel bucht, will man ja vorher das Hotel nicht auch noch selbst bauen.
Wenn man in einem Restaurant essen geht, will man ja auch kein Salz und Pfeffer mitnehmen, sondern dies soll geliefert werden.