Die Präsentation wird geladen. Bitte warten

Die Präsentation wird geladen. Bitte warten

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

Ähnliche Präsentationen


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; } v[0] v[1] v[2]

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

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

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

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

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

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

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

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

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

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

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

23 int main(){ int v[3]= {10,20,30}; f(v); } void f(int *p){ *p = 111; *(p+1) = 222; } v[0] v[1] v[2] ( *4) = 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; } v[0] v[1] v[2]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

50 Geben Sie die einzelnen Elemente des Feldes an:

51 // Feld ausdrucken for(i=0;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:

54 Weitere mögliche Lösung:

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

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

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

72 int istPositiv(const int v[], int anz){ int i=0; while(i1) 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]

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 Welche Zusicherung muss an die Input-Parameter gemacht werden:

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


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

Ähnliche Präsentationen


Google-Anzeigen