pointer und operanden hilfe

sanek

hallo leute.
bin neu hier.
suche einen pointer spezialisten.
komme mit dieser aufgabe nicht ganz klar
und zwar wollte ich wissen welche Werte nehmen B,C,D an und wie ändern die Pointer ihre Adresse dabei.

char b,c,d;
char a[]= {0xAA, 0xBB, 0xCD, 0xFE};
char *p = &A[1];
B= *(p--) & 0x78;
C= *(p+2) &~(( 1<<3)|(1<<7));
D=* ((p++) +1) | 23;

für hilfe danke ich im voraus

sanek

was mir problem bereite ist

D=* ((p++) +1) | 23;
pointer +1 zeigt auf 0xBB, ++ wird ja erst nach der rechnung gemacht.

wieso gibt mir rechner 0xbb | 0x13 = 0xbf
wenn ich per hand rechhne
13 00010011 oder
bb 10111011
= 10111011 und das ist wieder BB nicht BF

bitte wer hat ahnung?

oh kann sein dass 23 nicht in hexadezimal sondern in ascii umgewandelt wird,und dort ist es 0x17. dann passt es zum antwort auch.

_matze

sanek schrieb:

oh kann sein dass 23 nicht in hexadezimal sondern in ascii umgewandelt wird,und dort ist es 0x17. dann passt es zum antwort auch.

Ja, die 23 ist nicht hexadezimal, sondern dezimal (nicht ASCII). Hexadezimal notiert wäre 0x23.

sanek

kann mir jemand über prioritäten erzählen. was kommt zuerst ++, --, * () bin durcheinander. was wird angewendet adresse aus dem array oder wert der adresse.
danke

SeppJ

Google? Wikipedia? Jedes C-Buch?

sanek

habe ich schon gemacht. steht doch,bin durcheinander gekommen. bis 3 uhr nachts gestern. sonnst wäre ich nicht auf den forum gekommen.

_matze

Der Suchbegriff deiner Wahl lautet "operator precedence". Zum Beispiel findet man sowas hier:

http://en.wikipedia.org/wiki/Operators_in_C_and_C%2B%2B#Operator_precedence

sanek

ja das habe ich im script. aber ich verstehe es nicht.

D=*((p++) +1) | 23;

wird hier zuerst ++ gemacht ,dann pointer darauf? oder pointer so wie es war vorher, +1 zum wert des pointers. dann |. und danach pointer auf nächstes feld++

volkard

sanek schrieb:

ja das habe ich im script. aber ich verstehe es nicht.

D=*((p++) +1) | 23;

wird hier zuerst ++ gemacht ,dann pointer darauf? oder pointer so wie es war vorher, +1 zum wert des pointers. dann |. und danach pointer auf nächstes feld++

p
p++
(p++)
(p++)+1
((p++)+1)
*((p++)+1)
((p++)+1)|23
D=((p++)+1)|23

sanek

in welchen fall wird poscrement ++ erst nach operationen ausgeführt?

volkard

sanek schrieb:

in welchen fall wird poscrement ++ erst nach operationen ausgeführt?

eigentlich bindet es am stärksten.

a=p++;
ist gleich wie
a=(p++);

a=(*p)++;
haha, mit klammern kann man ihn zu allem zwingen.

wobei die inkrementierende wirkung natürlich erst später irgendwann stattfindet.

Postincrement wird immer nach der Operation ausgeführt.
Sonst wäre es ja Preincrement.
http://de.wikipedia.org/wiki/Post-

Das ++ steht hinter dem p, also wird erst der Wert von p für die weitere Rechnung genommen. (p wird danach weitergezählt)

D=*((p++) +1) | 23; 
// ist gleichwertig
D=*((++p)   ) | 23;

sanek

nach ihrer beschreibung muss ich hier -- auch zuertst machen?
aber so wäre es doch nicht correct wenn ich hier zuerst -- mache
p zeigt auf 0xBB
B= *(p--) & 0x78;
0xBB&0x78 = 0x38 und das ist richtig
-- wird ers danach gemacht und pointer geht auf 0xAA

sowie sie geschriben haben (als beispiel zuerst p++), müsste pointer zuerst auf 0xAA und danach 0xAA&0x78

oder liege ich falsch.
danke

sanek

volkard schrieb:

sanek schrieb:

in welchen fall wird poscrement ++ erst nach operationen ausgeführt?

eigentlich bindet es am stärksten.

a=p++;
ist gleich wie
a=(p++);

a=(*p)++;
haha, mit klammern kann man ihn zu allem zwingen.

wobei die inkrementierende wirkung natürlich erst später irgendwann stattfindet.

und das a=*(p++); heisst zuerst p verwenden wie es ist und danach p++ machen?

volkard

sanek schrieb:

und das a=*(p++); heisst zuerst p verwenden wie es ist und danach p++ machen?

Ja, genau. Nachher irgendwann wird p erhöht.

_matze

Dass der Postincrement-Operator bei p++ relativ früh ausgewertet wird, heißt nicht, dass p auch direkt erhöht wird. Das wird es erst nach der gesamten Operation.

sanek

dann sieht es so aus
char b,c,d;
char a[]= {0xAA, 0xBB, 0xCD, 0xFE};

char *p = &A[1];
//pointer zeigt auf 0xBB

B= *(p--) & 0x78;
//1) B=0xBB& 0x78 2) p-- ,pointer zeigt jetzt an 0xAA

C= *(p+2) &~(( 1<<3)|(1<<7));
//poinert ist auf 0xAA, p+2 (pointer geht auf 0xCD) oder wird 2 zum wert addiert 0xAA+2=0xAC???
//dann C=0xCD&~(( 1<<3)|(1<<7))
//oder dann C=0xAC&~(( 1<<3)|(1<<7))

D=* ((p++) +1) | 23;
//pointer ist immer noch auf 0xAA?
//p+1, pointer geht auf 0xBB, D=0xBB | 23
//danach p++, pointer geht auf 0xCD?

können sie bitte meine kommentare korrektieren.danke

char b,c,d,e;
  char a[]={0xAA, 0xBB, 0xCD, 0xFE};
  char *p=&a[1];                 /*0xBB*/
  b=*(p--) & 0x78;              /*1011 1011 & 0111 1000 = 0011 1000 = 0x38*/
  c=*(p+2) & ~(( 1<<3)|(1<<7)); /*1100 1101 & 0111 0111 = 0100 0101 = 0x45*/
  d=*((p++)+1) | 23;            /*1011 1011 | 0001 0111 = 1011 1111 = 0xBF*/
  e=*(p+++1) | 23;              /*1100 1101 | 0001 0111 = 1101 1111 = 0xDF so zum Spass*/

sanek

Querdenker1 schrieb:

char b,c,d,e;
  char a[]={0xAA, 0xBB, 0xCD, 0xFE};
  char *p=&a[1];                 /*0xBB*/
  b=*(p--) & 0x78;              /*1011 1011 & 0111 1000 = 0011 1000 = 0x38*/
  c=*(p+2) & ~(( 1<<3)|(1<<7)); /*1100 1101 & 0111 0111 = 0100 0101 = 0x45*/
  d=*((p++)+1) | 23;            /*1011 1011 | 0001 0111 = 1011 1111 = 0xBF*/
  e=*(p+++1) | 23;              /*1100 1101 | 0001 0111 = 1101 1111 = 0xDF so zum Spass*/

Querdenker1 schrieb:

char b,c,d,e;
  char a[]={0xAA, 0xBB, 0xCD, 0xFE};
  char *p=&a[1];                 /*0xBB*/
  b=*(p--) & 0x78;              /*1011 1011 & 0111 1000 = 0011 1000 = 0x38*/
  c=*(p+2) & ~(( 1<<3)|(1<<7)); /*1100 1101 & 0111 0111 = 0100 0101 = 0x45*/
  d=*((p++)+1) | 23;            /*1011 1011 | 0001 0111 = 1011 1111 = 0xBF*/
  e=*(p+++1) | 23;              /*1100 1101 | 0001 0111 = 1101 1111 = 0xDF so zum Spass*/

ja das ist korrekt. aber mich interessiert die pointerbewegung.
b=*(p--) & 0x78; /*1011 1011 (0xBB) & 0111 1000 = 0011 1000 = 0x38*/

pointer geht zu 0xAA (p--)

c=*(p+2) & ~(( 1<<3)|(1<<7)); /*1100 1101(0xAA+2=0xCD) & 0111 0111 = 0100 0101 = 0x45*/

pointer blibt auf 0xAA?

d=*((p++)+1) | 23; /*1011 1011 (hier steht aber wieder 0xBB)wieso? | 0001 0111 = 1011 1111 = 0xBF*/

und wohin zeigt pointer nach der letzten operation? 0xbb? weil p+1 nimmt nur den wert aus dieser stelle.d.h wert ist 0xbb pointer ist aber auf 0xaa.
p++ bewegt sich aber zu dieser stelle? d.h danach geht p auf oxbb wirklich.

sanek schrieb:

ja das ist korrekt. aber mich interessiert die pointerbewegung.
b=*(p--) & 0x78; /*1011 1011 (0xBB) & 0111 1000 = 0011 1000 = 0x38*/

pointer geht zu 0xAA (p--)

Ja.

sanek schrieb:

c=*(p+2) & ~(( 1<<3)|(1<<7)); /*1100 1101(0xAA+2=0xCD) & 0111 0111 = 0100 0101 = 0x45*/

pointer blibt auf 0xAA?

Ja.
Nebenbei ist die Klammerung bei *(p+2) ja eindeutig.
(Das (0xAA+2=0xCD) ist etwas unglücklich ausgedrückt)

sanek schrieb:

d=*((p++)+1) | 23; /*1011 1011 (hier steht aber wieder 0xBB)wieso? | 0001 0111 = 1011 1111 = 0xBF*/

und wohin zeigt pointer nach der letzten operation? 0xbb? weil p+1 nimmt nur den wert aus dieser stelle.d.h wert ist 0xbb pointer ist aber auf 0xaa.
p++ bewegt sich aber zu dieser stelle? d.h danach geht p auf oxbb wirklich.

Ja.