[C] Probleme mit einer Klausuraufgabe

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

Code:

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

Code:

*(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)