[C] Probleme mit einer Klausuraufgabe

[Whiz-zarD]

Gegeben seien die folgenden Variablen und Funktionen:


unsigned int x;
long int s;
float f;
unsigned char *p1;
int *p2;
void *p3;
int (*pf)(void);
void (*pf2)(double);
int f1(void);
int f2(int x1, int x2);
void f3(doube x1);


Bestimmen Sie für die folgenden Ausdrücke den Typ gemäß ANSI-C.
Vorsicht: Es kommen fehlerhafte Ausdrücke vor. Kennzeichnen Sie diese entsprechend.


*(p2 + x)
p3 + x
pf = f1()
*(p3 + x)
p1 == p3 ? f1 : pf
~p2
!p2
*p1 && p1
s || x
pf2 == f3
s | x
(*pf)(f1())
pf = f1
pf2 = f3
f = f3(f)
*p3
So lautet eine Aufgabe aus einer alten Klausur.
Ich hab bei dieser Aufgabe ein paar Verständnisprobleme.
Man soll jetzt ermitteln, welcher Datentyp aus den Ausdrücken resultiert, oder?
Wäre vielleicht ganz nett, wenn jemand diese Aufgabe lösen könnte.

[Drakes]

Hier mal die Fehler, mit dev-cpp überprüft:


*(p2 + x)
p3 + x -> Fehler, void-Pointer; keine Pointerarithmetik
pf = f1() -> Falsch, pf = f1 würde gehen
*(p3 + x) -> Fehler, void-Pointer; keine Pointerarithmetik
p1 == p3 ? f1 : pf
~p2 -> wrong type to bit-complement
!p2
*p1 && p1
s || x
pf2 == f3
s | x
(*pf)(f1()) -> zu viele Argumente ( int (*pf)(void) )
pf = f1
pf2 = f3
f = f3(f) -> f3 gibt void zurück
*p3 -> nicht möglich bei void*

[Whiz-zarD]

OK, danke erstmal. ^^

[Mog]

Hast du auch irgendwelche speziellen Fragen? Die Angabe ist doch recht klar, und das Beispiel ziemlich leicht, wenn man C verstanden hat. Insofern es etwas spezifisches gibt, wird bestimmt eher jemand helfen, als wenn man dir einfach so ein Beispiel loesen soll.

Ich fuer meinen Teil bin z.B. auch gerne bereit Loesungen zu ueberpruefen, allerdings bin ich da eher beim Mathe-Board-Konsens zu finden, wo derjenige, der Hilfe will, auch erst mal was vorzeigen muss. *Kratzt

[Whiz-zarD]

naja, ich dachte mir, dass einer vielleicht mal die Lösungen nennen könnte, damit ich diese dann mit meinen Gedanken vergleichen kann.

Da die Fehlerhaften sich nun geklärt haben, hab ich sie mal nun rausgenommen.



*(p2 + x) -> int, aber es müsste zu einer Bereichsüberschreitung kommen
p1 == p3 ? f1 : pf -> ?
!p2 -> int, nur eine 1 oder 0 wegen Negation
*p1 && p1 -> int, nur eine 1 oder 0 wegen logischem Und
s || x -> int, nur eine 1 oder 0 wegen logischem Oder
pf2 == f3 -> int, nur eine 1 oder 0 wegen Gleichheit
s | x -> long int (?)
pf = f1 -> ?
pf2 = f3 -> ?


Die mit einem ? markierten sind die, wo ich mir nicht im Klaren bin.
Ob die anderen so weit richtig sind, weiß ich auch nicht.

[Mog]

naja, ich dachte mir, dass einer vielleicht mal die Lösungen nennen könnte, damit ich diese dann mit meinen Gedanken vergleichen kann.

Da die Fehlerhaften sich nun geklärt haben, hab ich sie mal nun rausgenommen.



*(p2 + x) -> int, aber es müsste zu einer Bereichsüberschreitung kommen
p1 == p3 ? f1 : pf -> ?
!p2 -> int, nur eine 1 oder 0 wegen Negation
*p1 && p1 -> int, nur eine 1 oder 0 wegen logischem Und
s || x -> int, nur eine 1 oder 0 wegen logischem Oder
pf2 == f3 -> int, nur eine 1 oder 0 wegen Gleichheit
s | x -> long int (?)
pf = f1 -> ?
pf2 = f3 -> ?


Die mit einem ? markierten sind die, wo ich mir nicht im Klaren bin.
Ob die anderen so weit richtig sind, weiß ich auch nicht.




*(p2 + x)
=================
Int ist richtig, allerdings muss es nicht zwangsweise zu einem Uebertrag kommen. Die Kurzschreibweise waere p2[x]


Ev. solltest du dir auch noch die Lang-Schreibweise von foo->bar ueberlegen.

p1 == p3 ? f1 : pf
=================
Wenn die Addresse von p1 gleich der von p3 it, dann ist das Ergebnis f1, und wenn nicht pf. Da ich keinen Hinweis darauf finde, dass p1 == p3 ist, wuerde ich also zum Typen von pf hin tenieren.

Diesen Operator kannst du ir auch so vorstellen:

int foo;
if (1) foo = 1;
else foo = 2;

foo = (1)? 1 : 2;


!p2
=================
klingt richtig.


*p1 && p1
=================
int ist schon mal richtig. Wenn das Zeichen der aktuellen Speicheraresse entspricht, dann ist das Ergebnis 1, sonst 0. Also, jop. (EDIT: nah, nicht ganz. Ich hab da &, anstatt * gelesen gehabt. int stimmt trotzdem.)


s || x -> jop
=================
Korrekt.

pf2 == f3
=================
Korrekt.


s | x
=================
long int ist mindestens so lang, wie int, kann aber groesser sein.
unsigned int ist so gross, wie eine int.

dem logischen Operator ist die Zahlendarstellung egal. Somit wird es der groessere Typ sein. Dieser Typ entspricht immer der Groesse von long int.


pf = f1
=================
typeof (pf)


pf2 = f3
=================
typeof (pf2)



Ich schau spaeter noch mal ueber meinen Beitrag, ob stimmt, was ich jetzt auf die Schnelle geschrieben habe. Ich muss aber erstmal weg ^^"



\Drakes:
Void wird streng genommen nicht zurueck gegeben. Schau dir mal den Call in asm an.

[Drakes]

\Drakes:
Void wird streng genommen nicht zurueck gegeben. Schau dir mal den Call in asm an.

Ja, darum habe ich es zu den Fehlern geschrieben, der Compiler lässt das meines Wissens nach gar nicht zu.

Ausserdem hast du bei p1 == p3 ? f1 : pf übersehen dass der Typ von f1 und pf gleich ist. ;) (Mal abgesehen davon, dass man eventuell eher &f1 schreiben sollte)