Aufrufen einer Funktion, Parameter aus Array "C"

[Jakob (Gast)]

Hallo! Nachdem mir schon tatkräftig geholfen wurde und ich mich gerade 
mit dem Aufruf von Funktionen beschäfftige, ist gleich eine Frage 
aufgetaucht.

ich habe ein int-Array beliebiger Länge

...
werte[0]=0;
werte[1]=1;
werte[2]=2;
...

nun habe ich eine Funktion "Rechne" und möchte die Zahl "werte[i]" aus 
dem Array der Funktion zum Rechnen übergeben.
nun frag ich mich grade wie das genau geht.

void Rechne(int werte[i])
{ ... }

oder macht man das mit Zeigern

void Rechne(int *werte[])

oder ist beides vom Ergebnis her gleich, oder ist beides Unsinn!? Der 
Parameter i soll im Program variabel einstellbar sein.
Danke Jakob

[Klaus W. (mfgkw)]

Steht sowas nicht in deinem C-Buch?

[Thomas E. (thomase)]

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)

[Tim T. (tim_taylor)]

Auch wenns in wahrscheinlich JEDEM C-Buch steht:

void Rechne( int einwert ) {
...
}

int main( void ) {
...
 Rechne( Werte[ i ] );
...
}

[Karl H. (kbuchegg)]

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

>

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

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

   Rechne( 5 );

oder so

  int k = 8;
  Rechne( k );

oder gar so

  Rechne( k + 12 );

oder eben so

  Rechne( werte[i] );

immer bekommt die Funktion einen int übergeben.

Und daher definierst du die Funktion dann auch so

void Rechne( int derWert )
{ ... }

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.

[Brummer (Gast)]

Ich habe da irgendwie nen Denkfehler drin gehabt, aber durch deine 
Erklärung hab ich es jetzt verstanden.

[Loonix (Gast)]

Thomas Eckmann schrieb:
> Jakob schrieb:
>> void Rechne(int werte[i])
>>
>> { ... }
>
> das ist ja nun völliger Blödsinn

...und mal wieder Einer der auf dicke Hose macht, weil er in 
C-Grundlagen einem Anfänger überlegen ist...

Nehmt euch lieber mal ein Beispiel an der Engelsgeduld von Karl-Heinz 
Buchegger!

[Karl H. (kbuchegg)]

> ... hab ich es jetzt verstanden.

Gut, das ist nämlich wichtig.

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

int foo( int wert )
{
  return wert + 2;
}

int main()
{
  int wert = 5;
  int i;

  i = foo( wert );
}

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

int main()
{
  int i;

  i = foo( foo(5) );
]

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.

[Wolfgang B. (et-tutorials)]

Vielleicht hilft da mein Video-Tutorial

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

Folgen 36 - 38