Aufrufen einer Funktion, Parameter aus Array "C"

Steht sowas nicht in deinem C-Buch?

Jakob schrieb:
> void Rechne(int werte[i])
>
> { ... }

das ist ja nun völliger Blödsinn

wenn schon
int /* oder wo soll das Ergebnis hin*/ Rechne(int nA, int nB)

Jakob schrieb:
> ich habe ein int-Array beliebiger Länge

ok


> nun habe ich eine Funktion "Rechne" und möchte die Zahl "werte[i]" aus
> dem Array der Funktion zum Rechnen übergeben.

gut

>

1

> void Rechne(int werte[i])

2

> { ... }

3

>

Das kanns ja wohl nicht sein.
Die Funktion Rechne übernimmt einen int. Wo dieser int her kommt, in 
deinem Fall aus einem Array, hat doch die Funktion nicht zu 
interessieren.

Ob du die Funktion so aufrufst

1

   Rechne( 5 );

oder so

1

  int k = 8;

2

  Rechne( k );

oder gar so

1

  Rechne( k + 12 );

oder eben so

1

  Rechne( werte[i] );

immer bekommt die Funktion einen int übergeben.

Und daher definierst du die Funktion dann auch so

1

void Rechne( int derWert )

2

{ ... }

Funktionen sind und sollen davon unabhängig sein, wo der Wert herkommt, 
der ihnen in der Argumentliste übergeben wird. Es hat die Funktion 
einfach nicht zu interessuieren. Später wirst du dann irgendwann lernen, 
wie man diesen Mechanismus aushebeln kann, so dass die Funktion dann 
auch tatsächlich auf eine Variable des Aufrufers durchgreifen kann. Aber 
im Moment ist das nicht notwendig.

> ... hab ich es jetzt verstanden.

Gut, das ist nämlich wichtig.

Viele Neulinge glauben nämlich, dass es in diesem Beispiel

1

int foo( int wert )

2

{

3

  return wert + 2;

4

}

5

6

int main()

7

{

8

  int wert = 5;

9

  int i;

10

11

  i = foo( wert );

12

}

zwischen der Variablen 'wert' in main und dem Parameter 'wert' in foo 
einen magischen Zusammenhang gibt. Da gibt es aber keinen. Das sind 2 
getrennte Variablen, die nur zufällig den gleichen Namen tragen. Es 
würde sich nichts ändern, wenn man das 'wert' in foo 'schnurdiburr' 
nennen würde.
Beim Aufruf einer Funktion werden die Funktionsargumente ausgewertet, 
ihr Wert festgestellt

int main
{
  ...
  i = foo( wert );

an dieser Stelle wird festgestelle, dass wert momentan den Zahlenwert 5 
hat. Diese 5 werden genommen und

int foo( int wert )

an die hier angegebene Parametervariable, die zufälligerweise auch 
'wert' heisst, gebunden. Innerhalb der Funktion beginnt diese Variable 
ihr Leben damit, dass sie die 5 vom Aufrufer als Initialwert bekommt.

Das bedeutet aber auch, dass es keinen Zusammenhang zwischen den 
Variablen hier
    i = foo( wert );
und den Variablen hier
int foo( int wert )
gibt, ausser dass die Zahlenwerte von dem einen auf die anderen 
übertragen werden.

Und damit ist es einer Funktion auch egal, wie genau der Zahlenwert 
entsteht, den sie bekommt. Das ist nicht ihr Bier und passiert auf der 
anderen Seite einer imaginären Grenze an der der Einflussbereich der 
Funktion beginnt.
Da diese Funktion selber wieder einen int returniert (sie liefert einen 
int), ist das hier völlig in Ordnung

1

int main()

2

{

3

  int i;

4

5

  i = foo( foo(5) );

6

]

Die Funktion foo wird mit 5 als Argument aufgerufen (der innere Aufruf) 
und liefert wieder einen int (mit dem Wert 7). Dieser int (die 7) wird 
erneut in einen Funktionsaufruf der Funktion foo hineingesteckt und die 
Funktion wird damit noch einmal aufgerufen und liefert ein Ergebnis (9), 
welches in diesem Fall dann an i zugewiesen wird. Man hätte es aber auch 
an jeder anderen beliebigen Stelle benutzen können, an der ein int 
gefordert ist.

Vielleicht hilft da mein Video-Tutorial

http://et-tutorials.de/mikrocontroller/

Folgen 36 - 38