Funktionen, Felder und Parameter- übergabe. Funktionsaufruf mit Feld als Parameter: Parameter = Name des Feldes.

Präsentation zum Thema: "Funktionen, Felder und Parameter- übergabe. Funktionsaufruf mit Feld als Parameter: Parameter = Name des Feldes."—  Präsentation transkript:

1 Funktionen, Felder und Parameter- übergabe

2 Funktionsaufruf mit Feld als Parameter: Parameter = Name des Feldes

3 Beispiel:... int main(){ int v[3] = {10,20,30}; f(v);... }

4 Intern bedeutet dies: Die Adresse des nullten Elements (Komponente) des Feldes wird an die Funktion übergeben.

5 Beispiel:... int main(){ int v[3] = {10,20,30}; f(v); // gleichbedeutend mit: f(&v[0]);... } Dies ist eine ADRESSE

6 Wie muss also der formale Parameter in der Definition der Funktion deklariert werden ?

7 int main(){ int v[3] = {10,20,30}; f(v); } void f( ){ *p = 111; *(p+1) = 222; } int *p Dies ist ein POINTER auf einen integer Für Leute, die Pointer nicht mögen, gibt es eine alternative Syntax, in der mehr der Charakter des Feldes betont wird //void f(int p[]){

8 void f(int v[]){ *p = 111; *(p+1) = 222; } Die beiden Schreibweisen sind gleichwertig... int main(){ int v[3] = {10,20,30}; f(v); } Und in der nächsten Folie gehen wir wieder zurück zur Pointerschreibweise...

9 int main(){ int v[3] = {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; }

10 Was geschieht beim Ablauf des Programms ?

11 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

12 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

13 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

14 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

15 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

16 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

17 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

18 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

19 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

20 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0138

21 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 0138111v[0] 014220v[1] 014630v[2]... 0138

22 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 0138111v[0] 014220v[1] 014630v[2]... 0138 (0138+1 0138 *4) =0142 0138

23 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } 0138111v[0] 0142222v[1] 014630v[2]... 0138 (0138+1 *4) =0142 0138 Welche Art von Parameter ist p ? (i), (o), (i/o) Ein Input-Output- Parameter, also (i/o)

24 Frage: Wie ist der Programmablauf beim Aufruf von f(&v[0])

25 Antwort: Wie beim Aufruf von f(v)

26 Frage: Wie ist der Programmablauf beim Aufruf von f(&v[1])

27 int main(){ int v[3] = {10,20,30}; f(&v[1]); } void f( ){ *p = 111; *(p+1) = 222; } int *p

28 Was geschieht beim Ablauf des Programms ?

29 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

30 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

31 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

32 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

33 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

34 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

35 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

36 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

37 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

38 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

39 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

40 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

41 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

42 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

43 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 014220v[1] 014630v[2]... 0142

44 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 0142111v[1] 014630v[2]... 0142

45 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 0142111v[1] 014630v[2]... 0142 (0142+1 0142 *4) =0146 0142

46 int main(){ int v[3]= {10,20,30}; f(&v[1]); } void f(int *p){ *p = 111; *(p+1) = 222; } 013810v[0] 0142111v[1] 0146222v[2]... 0142 (0142+1 *4) =0146 0142

47 Aufgabe:

48 Erstellen Sie die Funktion reset, die eine bestimmte Anzahl sich hintereinander befindlicher Elemente eines Integer-Feldes auf 0 setzt. Testen Sie danach die Funktion in einem Programm.

49 // includes vorher einfügen const int len = 10; void reset1(int *p, int von, int bis); int main(){ int zahlen[len]; int i; // Feld irgendwie füllen for(i=0;i<len;i++){ zahlen[i] = 10+2*i; }

50 Geben Sie die einzelnen Elemente des Feldes an: 10121416182022242628

51 // Feld ausdrucken for(i=0;i<len;i++){ printf("%d ",zahlen[i]); } printf("\n"); reset1(zahlen, 3, 7); // Feld ausdrucken for(i=0;i<len;i++){ printf("%d ",zahlen[i]); } }

52 void reset1(int *p, int von, int bis){ int i; for(i=von; i<=bis; i++){ *(p+i)=0; } }

53 Geben Sie die einzelnen Elemente des Feldes an: 101214000002628

54 Weitere mögliche Lösung:

55 void reset2(int *p, int anz){ int i; for(i=0; i<anz; i++){ *(p+i)=0; } }

56 int main(){ //... // statt // reset1(zahlen, 3, 7); // alternativ: reset2( ); //... } &zahlen[3], 5

57 Weitere mögliche Lösung:

58 void reset3(int *von, int *bis){ while(von <= bis){ *von=0; von=von+1; } }

59 int main(){ //... // statt // reset1(zahlen, 3, 7); // alternativ: reset3( } &zahlen[3], &zahlen[7] );

60 Wie müssen die Adressen der Feldelemente organisiert sein, damit diese Lösung funktioniert? void reset3(int *von, int *bis){ while(von <= bis){ *von=0; von=von+1; } } Adresse Feldelement 0 < Adresse Feldelement 1 < Adresse Feldelement 2 < …

61 Aufgabe:

62 V erändern Sie die Funktion reset1 so, dass der Programmierer, der sie verwendet, bestimmen kann, auf welchen Wert (nicht nur 0), die Elemente gesetzt werden sollen. Die veränderte Funktion soll reset1a heissen.

63 void reset1a(int *p, int von, int bis, int wert){ int i; for(i=von; i<=bis; i++){ *(p+i)=wert; } }

64 Alternative Syntax bei der Definition einer Funktion mit einem Feld als Parameter

65 int main(){ int v[3] = {10,20,30}; f(v); } void f(int p[]){ p[0]= 111; // *p=111 p[1] = 222; // *(p+1)=222 } p[1]*(p+1) z.B. ist gleichbedeutend mit Dies gilt NUR innerhalb der Definition (Implementierung) der Funktion (unten).

66 Funktionsaufruf mit Feld als reinem Input-Parameter.

67 Aufgabe: Erzeugen Sie eine Funktion mit einem Feld als Parameter. Das Feld soll nur daraufhin überprüft werden, ob seine Elemente positive Werte haben.

68 int istPositiv(int v[], int anz){ int i=0; while(i<anz){ if(v[i]<0) return(-1); i=i+1; } return(0); } Welche Art von Parameter ist das Feld v ? (i), (o), (i/o) Ein reiner Input- Parameter, also (i) Ein unkonzentrierter Programmierer könnte z.B. folgendes machen: v[i] = v[i+1]; Welche Art von Parameter ist dann das Feld v ? v ist dann ein (i/o)- Parameter.

69 // Hier ist noch das // Hauptprogramm int main(){ int erg; int w[4]={11,12,-6,9}; erg=istPositiv(w,4); printf("erg=%d\n",erg); return(0); } Welchen Wert hat erg ? erg hat den Wert –1, da mindestens ein Element einen negativen Wert hat.

70 Um ein Feld als reinen Input-Parameter (read-only- Speicher) zu benutzen, d.h. es (schreibgeschützt) gegen Veränderungen durch den Programmierer zu schützen, kann man den Parameter mit const als eine Konstante deklarieren.

71 int istPositiv(const int v[], int anz){ int i=0; while(i<anz){ if(v[i]<0) return(-1); i=i+1; } return(0); } Was würde mit einem unkonzentrierten Programmierer passieren, wenn er folgendes macht: v[i] = v[i+1]; Er bekommt eine Fehlermeldung des Compilers.

72 int istPositiv(const int v[], int anz){ int i=0; while(i<anz){ if(v[i]<0) return(-1); i=i+1; } return(0); } Welchen Parameter könnte man auch noch schreibschützen? while(anz>1) anz=anz+1; Was müsste man dazu tun? Diesen Input-Parameter const Ist dies sinnvoll? Da anz kein Pointer, kann sein Wert doch nach außen nicht geändert werden. Endlosschleife, deswegen sinnvoll

73 Aufgabe: Erzeugen Sie eine Funktion, die ein Integer-Feld der Länge 2 der Größe nach aufsteigend sortiert. 2 Lösungsvarianten machen

74 1. Lösung

75 void my1Sort2(const int vI[], int vO[]){ if(vI[0]<vI[1]){ vO[0]=vI[0]; vO[1]=vI[1]; } else{ vO[0]=vI[1]; vO[1]=vI[0]; } } Welche Art von Parameter ist das Feld vI und vO ? (i), (o), (i/o) vI : (i), also reiner Input-Parameter vO : (o), also reiner Output-Parameter

76 2. Lösung

77 void my2Sort2(int v[]){ int temp0, temp1; temp0=v[0]; temp1=v[1]; if(v[0]>v[1]){ v[0]=temp1; v[1]=temp0; } } Welche Art von Parameter ist das Feld v ? (i), (o), (i/o) v : (i/o), also Input- und Output-Parameter

78 void my2Sort2(int v[]){ int temp0, temp1; temp0=v[0]; temp1=v[1]; if(v[0]>v[1]){ v[0]=temp1; v[1]=temp0; } } Die Werte von v[0] und v[1] werden vertauscht. Was veranlassen die 2 Anweisungen der if Anweisug? Könnte man dies auch wie folgt realisieren?

79 void my2Sort2(int v[]){ int temp0, temp1; temp0=v[0]; temp1=v[1]; if(v[0]>v[1]){ v[0]=v[1]; v[1]=v[0]; } } Angenommen, vor diesen 2 Anweisungen wäre v[0] und v[1] wie folgt belegt: v[0] : 10 und v[1] : 20 Wie wäre dann v[0] und v[1] danach belegt? v[0] : 20 v[1] : 20

80 Welche Zusicherung muss an die Input-Parameter gemacht werden:

81 Sie müssen die Länge 2 haben.

82 Zeichenkette als Parameter beim Aufruf einer Funktion.

83 Frage: Wie wird in C eine Zeichenkette realisiert?

84 Als Folge von Zeichen (char), die durch Anführungszeichen getrennt werden, wie z.B: "Hallo Welt" oder...

85 als ein Feld (Array) vom Datentyp char.

86 Was macht folgende Funktion?

87

88 void ausgabe(char feld[]){ int i; for(i=0;feld[i]!='\0';i++){ printf("%c",feld[i]); } printf("\n"); } gibt alle Zellen des Feldes auf dem Bildschirm aus. Wie könnten mögliche Aufrufe dieser Funktion in main() aussehen?

89 int main(){ char name[5]="MESK"; ausgabe(name); // auch moeglich ausgabe("Hallo"); } Die Zeichenfolge "Hallo" kann "hart kodiert" werden, muß also nicht über eine Variable (wie z.B. name passieren).