Funktion mit mehreren Argumenten

[Dennis (Gast)]

Hey Leute, ich habe folgende Aufgabe in der Schule nicht verstanden, ich 
hoffe ihr könnt mir helfen, da ich gerade für eine Klausur lerne.
Ich habe folgenden Code gegeben und soll bestimmen, was das Endergebnis 
ist,das auf dem Bildschirm angezeigt wird:

#include <stdio.h>
#include <stdarg.h>

void main( void ){
int willy = harry( 2, 1, 2, 3, -2, -3 );
printf("%i", willy);
}

int harry( int zahl, ...){
int ergebnis = 0;
va_list arg_ptr;
va_start(arg_ptr, zahl);
ergebnis += va_arg(arg_ptr, int);
ergebnis += va_arg(arg_ptr, int);
ergebnis += va_arg(arg_ptr, int);
va_end(arg_ptr);
return( ergebnis );
}

Addieren sich die Argumente einzeln, sprich: (2+2+2+2,1+1+1+1,......) ?
somit wäre das Ergebnis: (8,4,8,12,-8,-12)

oder addieren sich die Argumente im gesamten, sprich: (2+1+2+3-2-3)*3 ?
somit wäre das Ergebnis: (9)

Leider kann ich den Code nicht in einfach testen , da es einige Fehler 
zu geben scheint!

[Dennis (Gast)]

Hey ich bin es nochmal.
Ich bereite mich gerade auf eine Informatikklausur (C) vor und habe ein 
Problem bei folgender Aufgabe:



Wie ist der Aufruf in Zeile 4 korrekt zu ergänzen, damit anschließend 
auf den ersten variablen Parameter der Funktion tueIrgendwas zugegriffen 
werden kann?

1: int tueIrgendwas( int iWert, float fWert, ...)
2: {
3: va_list pArg;
4: va_start(


Meine Lösung: pArg,iWert);

Ist diese korrekt?
MfG Dennis

[Johann L. (gjlayde)]

Lesen kannst aber?

http://linux.die.net/man/3/stdarg

Die Aufgabe ist so nicht lösbar, denn es fehlt das Include von stdarg.h

[Karl H. (kbuchegg)]

Dennis schrieb:
> Hey ich bin es nochmal.
> Ich bereite mich gerade auf eine Informatikklausur (C) vor und habe ein
> Problem bei folgender Aufgabe:
>
>
>
> Wie ist der Aufruf in Zeile 4 korrekt zu ergänzen, damit anschließend
> auf den ersten variablen Parameter der Funktion tueIrgendwas zugegriffen
> werden kann?
>
> 1: int tueIrgendwas( int iWert, float fWert, ...)
> 2: {
> 3: va_list pArg;
> 4: va_start(
>
>
> Meine Lösung: pArg,iWert);

Nein.
übliche Leseart in unserem Kulturkreis ist von links nach rechts. D.h. 
der letzte benannte Parameter in der Argumentliste war fWert. Bei 
va_start gibst du den letzten benannten Parameter an.

http://www.cplusplus.com/reference/cstdarg/va_start/

[Dr. Sommer (Gast)]

Dennis schrieb:
> Leider kann ich den Code nicht in einfach testen , da es einige Fehler
> zu geben scheint!
Wie wärs dann damit, damit anzufangen, die Fehler zu beheben?

Der Rückgabetyp von "main" muss "int" sein, nicht void. Vor der "main" 
Funktion muss erst die "harry"-Funktion deklariert werden.

Dennis schrieb:
> Addieren sich die Argumente einzeln, sprich: (2+2+2+2,1+1+1+1,......) ?
> somit wäre das Ergebnis: (8,4,8,12,-8,-12)
>
> oder addieren sich die Argumente im gesamten, sprich: (2+1+2+3-2-3)*3 ?
> somit wäre das Ergebnis: (9)

Weder noch. Schau dir den Code an:

Dennis schrieb:
> ergebnis += va_arg(arg_ptr, int);
> ergebnis += va_arg(arg_ptr, int);
> ergebnis += va_arg(arg_ptr, int);
Wie viele Additionen zählst du hier? Wie viele Zahlen werden hier also 
addiert? Und wie kommst du überhaupt auf *3 ?

Überraschenderweise ist die Funktion von va_arg usw. dokumentiert. Wie 
wäre es damit das zu lesen und dann zu überlegen was der Code tut?
https://en.wikipedia.org/wiki/Stdarg.h
http://www.cplusplus.com/reference/cstdarg/

[Johann L. (gjlayde)]

Das Programm zeigt Undefined Behaviour, da für den korrekten Aufruf von 
harry() dessen Definition / Deklaration fehlt.

[Dennis (Gast)]

Nach einiger Überlegung ist mir aufgefallen, dass ich das ergebnis = 0 
übersehen habe.
somit wäre ja:

harry( 2, 1, 2, 3, -2, -3 );   = 3

dann folgt:

ergebnis += va_arg(arg_ptr, int);
ergebnis += va_arg(arg_ptr, int);
ergebnis += va_arg(arg_ptr, int);

also wäre das Egebnis 9, richtig?

[Daniel A. (daniel-a)]

Der code Compiliert nicht weil die funktion harry vor der ersten 
Verwendung noch nicht Deklariert wirde.

Das Ergebnis ist 6:
va_start benötigt als Zweites argument das letzte Argument vor der 
Parameterliste der Funkion in der es steht, tut damit aber nichts. 
va_arg liefert das nächste Argument. Es werden 3 argumente der variablen 
argumentliste mit va_arg geholt, addiert und zurückgegeben. Jedes 
Argument das keinem Parameter der funktion entspricht ist teil der 
Argumentliste, das erste argument von harry ist zahl und gehlrt zum 
ersten parameter von harry, "zahl". Der rest ist teil der variablen 
argumentliste. Somit werden 1, 2, und 3 addiert, das ergiebt 6

[Dr. Sommer (Gast)]

Dennis schrieb:
> also wäre das Egebnis 9, richtig?
Nö.

Die "harry" Funktion ist im übrigen ziemlich bescheuert, weil sie eine 
feste Anzahl an Argumenten zum Funktionieren braucht (4) aber dennoch 
eine variadische Parameterliste hat, und außerdem das erste Argument und 
alle ab dem 5. ignoriert.

[Karl H. (kbuchegg)]

Dennis schrieb:

> Addieren sich die Argumente einzeln, sprich: (2+2+2+2,1+1+1+1,......) ?
> somit wäre das Ergebnis: (8,4,8,12,-8,-12)

Du scheinst da eine sehr seltsame Sichtweise zu haben.

va_arg holt genau 1 Wert von der Argumentliste. Nicht mehr und auch 
nicht weniger.

wenn du also einen Aufruf hast

   ... harry( 2, 1, 2, 3, -2, -3 );

dann geht die erste 2 an die Variable zahl. Denn die ist in der 
Argumentliste ja als erstes

int harry( int zahl, ...)
               ****

die erste Benutzung von va_arg bringt dir die 1

   ... harry( 2, 1, 2, 3, -2, -3 );
                ***

die nächste Benutzung eine 2

   ... harry( 2, 1, 2, 3, -2, -3 );
                   ***

und die dritte Benutzung die 3

   ... harry( 2, 1, 2, 3, -2, -3 );
                      ***

da keine weiteren va_arg Benutzungen mehr im Code vorkommen, werden die 
restlichen Argument nicht weiter benutzt.

Was also ist das Ergebnis von

  ergebnis = 0;
  ergebnis += va_arg(arg_ptr, int);
  ergebnis += va_arg(arg_ptr, int);
  ergebnis += va_arg(arg_ptr, int);

oder wenn wir die Zahlen einsetzen

  ergebnis = 0;
  ergebnis += 1;   // geliefert vom ersten va_arg
  ergebnis += 2;   // geliefert vom zweiten va_arg
  ergebnis += 3;   // geliefert vom dritten va_arg

[Dennis (Gast)]

Vielen Dank für die zahlreichen und schnellen Antworten!

Ich habe jetzt alles verstanden, außer, wieso die 2 nicht erscheint.

ist es wegen " va_start(arg_ptr, zahl); " ?
arg_ptr ruft also die 2 auf und schreibt sie in "zahl", richtig?

[Dennis (Gast)]

Karl H. schrieb:
> Nein.
> übliche Leseart in unserem Kulturkreis ist von links nach rechts. D.h.
> der letzte benannte Parameter in der Argumentliste war fWert. Bei
> va_start gibst du den letzten benannten Parameter an.

also va_start(pArg,fWert); ?

Somit würde wäre iWert der erste ausgegebene Wert richtig?

[Rufus Τ. F. (rufus)]

Dennis schrieb:
> Somit würde wäre iWert der erste ausgegebene Wert richtig?

Nein. Der fällt unter den Tisch, wie fWert auch.

[Dennis (Gast)]

und wie greife ich dann auf den ersten Wert zu, bzw was ist denn dann zu 
ergänzen, wenn beides unter den Tisch fällt?

[Karl H. (kbuchegg)]

Dennis schrieb:
> Vielen Dank für die zahlreichen und schnellen Antworten!
>
> Ich habe jetzt alles verstanden, außer, wieso die 2 nicht erscheint.
>
> ist es wegen " va_start(arg_ptr, zahl); " ?
> arg_ptr ruft also die 2 auf und schreibt sie in "zahl", richtig?

Nein.
arg_ptr ruft überhaupt nichts auf.

arg_ptr richtet die arg_list so ein, dass die erste Benutzung von va_arg 
das nächste Argument von der Argumentliste holt, das nach dem benannten 
Parameter 'zahl' auftaucht.

Die erste 2 wird ganz normal an den ersten benannten Parameter gebunden

    harry(       2, 1, 2, 3, -2, -3 );
                 |
                 |
                 v
 int harry( int zahl, ...){

[Karl H. (kbuchegg)]

Dennis schrieb:
> und wie greife ich dann auf den ersten Wert zu, bzw was ist denn dann zu
> ergänzen, wenn beides unter den Tisch fällt?

Ähm. Über den Variablennamen des Parameters?

 int tueIrgendwas( int iWert, float fWert, ...)
 {
   int irgendwas = iWert + fWert;

   ....

mit denen gibt es ja kein Problem. Die haben ja Variablennamen. Nur 
alles was danach kommt, dafür hast du keinen Namen mit dem du es 
ansprechen könntest.

Rück mal ein wenig zur Seite. Du sitzt gerade mächtig auf der Leitung. 
Das ist viel einfacher als du jetzt denkst.

[Dennis (Gast)]

Ahhh, jetzt habe ich das verstanden =)
Vielen Dank Karl Heinz, diese Erklärung hat mir sehr geholfen.

Die zweite Aufgabe verstehe ich allerdings immer noch nicht... :(

[Karl H. (kbuchegg)]

Dennis schrieb:
> Ahhh, jetzt habe ich das verstanden =)
> Vielen Dank Karl Heinz, diese Erklärung hat mir sehr geholfen.
>
> Die zweite Aufgabe verstehe ich allerdings immer noch nicht... :(

was verstehst du daran nicht.

Beim Aufruf von

 int tueIrgendwas( int iWert, float fWert, ...)

welches ist denn der erste 'variable Parameter'?

Na der der nach fWert kommt. Denn die ersten beiden sind ja fix. Die 
ersten beiden müssen sein, sind also nicht variabel in dem Sinne dass 
sie da sein können oder auch nicht.

Mit dem Protoypen klopft dir ein Compiler auf die Finger wenn du

   tueIrgendwas( 5 );

machen willst. Denn die Funtkion fordert mindestens 2 Argumente. 2 
Argumente sind fix gefordert.

  tueIrgendwas( 5, 8 );

wäre also ok.
Aber auch

  tueIrgendwas( 5, 8, 3 );

ist ok. die 3 ist halt der erste variable Paramater. er kann da sein, 
muss aber nicht.

Wenn also standardmässig sowieso erst mal die Bindung an die benannten 
fixen Parameter erfolgt

  tueIrgendwas(          5,           8,      3 );
                         |            |
                         |            |
                         v            v      
 int tueIrgendwas( int iWert, float fWert, ...)

welche ist dann der letzte benannte Parameter ehe dann der variable Teil 
der Argumentliste anfängt?
Genau - fWert.
setzt du die va_list so mit einem va_start auf fWert auf, dann liefert 
der erste va_arg dann eben die 3

[Dennis (Gast)]

Ich sitze vermutlich schon viel zu lange vor dem Bildschirm und sollte 
eine Pause machen...

wenn ich also also
va_start(pArg,fWert);
aufrufe, dann würde in deinem Beispiel mit einem Aufruf von va_arg die 3 
ausgegeben werden, weil diese der erste Variable Wert ist.

[Karl H. (kbuchegg)]

Dennis schrieb:
> Ich sitze vermutlich schon viel zu lange vor dem Bildschirm und sollte
> eine Pause machen...
>
> wenn ich also also
> va_start(pArg,fWert);
> aufrufe, dann würde in deinem Beispiel mit einem Aufruf von va_arg die 3
> ausgegeben werden, weil diese der erste Variable Wert ist.

An dieser Stelle sind wir soweit, dass man mit Fug und Recht behaupten 
kann:
Du hast einen Compiler vor dir. Probier es aus.

[Dennis (Gast)]

Vielen Dank für deine Geduld mit mir Karl Heinz,
ich glaube, dass ich es jetzt wirklich verstanden habe
(der Compiler sagt mir dann tatsächlich 3 )

=)

[DirkB (Gast)]

Bei

int tueIrgendwas( int iWert, float fWert, ...)
tueIrgendwas( 5, 8, 3 );

Wird die 8 auch in ein float gewandelt

Karl H. schrieb:
> Du hast einen Compiler vor dir. Probier es aus.

Da muss man aber aufpassen.
Nicht alles was dein Compiler macht, macht auch ein anderer Compiler.
In C gibt es genug Freiheiten und UB (undefined behaviour)