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

Funktionen, Felder und Parameter-übergabe

Funktionsaufruf mit Feld als Parameter:

Parameter =Name des Feldes

Beispiel:

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

Intern bedeutet dies:

Die Adresse des nullten Elements (Komponente) des Feldes wird an die Funktion übergeben.

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

f(&v[0]);

...}

Dies ist eine ADRESSE

Wie muss also der formale Parameter in der Definition

der Funktion deklariert werden ?

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[]){

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 ...

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

void f(int *p){ *p = 111; *(p+1) = 222;}

Was geschieht beim Ablauf des Programms ?

int main(){

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

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 10v[0]0142 20v[1]0146 30v[2]

...

...0138

int main(){

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

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 10v[0]0142 20v[1]0146 30v[2]

...

...

0138

int main(){

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

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 10v[0]0142 20v[1]0146 30v[2]

...

...

0138

0138

0138

int main(){

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

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 111v[0]0142 20v[1]0146 30v[2]

...

...

0138

0138

0138

int main(){

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

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 111v[0]0142 20v[1]0146 30v[2]

...

...

0138

(0138+1

0138

*4)=0142

0138

int main(){

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

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 111v[0]0142 222v[1]0146 30v[2]

...

...

0138

0138

(0138+1*4)=0142

0138

Welche Art von Parameter ist p ?(i), (o), (i/o)

Ein Input-Output-Parameter, also (i/o)

Frage:Wie ist der Programmablauf

beim Aufruf von

f(&v[0])

Antwort:Wie beim Aufruf von

f(v)

Frage:Wie ist der Programmablauf

beim Aufruf von

f(&v[1])

int main(){

int v[3] = {10,20,30}; f(&v[1]);}

void f( ){

*p = 111; *(p+1) = 222;}

int *p

Was geschieht beim Ablauf des Programms ?

int main(){

int v[3]= {10,20,30}; f(&v[1]);

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 10v[0]0142 20v[1]0146 30v[2]

...

...0142

int main(){

int v[3]= {10,20,30}; f(&v[1]);

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 10v[0]0142 20v[1]0146 30v[2]

...

...

0142

int main(){

int v[3]= {10,20,30}; f(&v[1]);

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 10v[0]0142 20v[1]0146 30v[2]

...

...

0142

0142

0142

int main(){

int v[3]= {10,20,30}; f(&v[1]);

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 10v[0]0142 111v[1]0146 30v[2]

...

...

0142

0142

0142

int main(){

int v[3]= {10,20,30}; f(&v[1]);

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 10v[0]0142 111v[1]0146 30v[2]

...

...

0142

(0142+1

0142

*4)=0146

0142

int main(){

int v[3]= {10,20,30}; f(&v[1]);

}

void f(int *p){

*p = 111; *(p+1) = 222;}

0138 10v[0]0142 111v[1]0146 222v[2]

...

...

0142

(0142+1*4)=0146

0142

0142

Aufgabe:

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.

// includes vorher einfügenconst 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; }

Geben Sie die einzelnen Elemente des Feldes an:

10 12 14 16 18 20 22 24 26 28

// 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]); }}

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

Geben Sie die einzelnen Elemente des Feldes an:

10 12 14 0 0 0 0 0 26 28

Weitere mögliche Lösung:

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

int main(){

// ... // statt // reset1(zahlen, 3, 7); // alternativ:

reset2( ); // ...

}

&zahlen[3], 5

Weitere mögliche Lösung:

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

}}

int main(){

// ... // statt // reset1(zahlen, 3, 7); // alternativ:

reset3(

}

&zahlen[3], &zahlen[7] );

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 <…

Aufgabe:

Verä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.

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

Alternative Syntax bei der Definition einer Funktion

mit einem Feld als Parameter

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).

Funktionsaufruf mit Feld als reinem Input-Parameter.

Aufgabe:Erzeugen Sie eine Funktion

mit einem Feld als Parameter. Das Feld soll nur daraufhin überprüft werden, ob seine Elemente positive

Werte haben.

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.

// 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.

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.

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.

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

Aufgabe:Erzeugen Sie eine Funktion,

die ein Integer-Feld der Länge 2 der Größe nach

aufsteigend sortiert.2 Lösungsvarianten machen

1. Lösung

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-ParametervO : (o), also reiner Output-Parameter

2. Lösung

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

Welche Zusicherung muss an die Input-Parameter

gemacht werden:

Sie müssen die Länge 2 haben.

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

Documents

Transcript of Funktionen, Felder und Parameter- übergabe. Funktionsaufruf mit Feld als Parameter: Parameter =...