pointer und operanden hilfe

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.

sanek

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

pointer blibt auf 0xAA?[/quote]
Ja.
Nebenbei ist die Klammerung bei *(p+2) ja eindeutig.
(Das (0xAA+2=0xCD) ist etwas unglücklich ausgedrückt)

besser zu sagen. p = 0xaa, durch +2 bekommt wert 0xcd für weitere operation
bleibt aber trotzdem auf 0xaa
??

Du meinst schon das richtige.
Nur ist p nicht 0xAA, sondern p verweist auf 0xAA
(ich schlage mal ~> für verweist vor)

p ~> 0xaa, durch +2 verweist auf 0xcd für weitere operation

sanek

DirkB schrieb:

Du meinst schon das richtige.
Nur ist p nicht 0xAA, sondern p verweist auf 0xAA
(ich schlage mal ~> für verweist vor)

p ~> 0xaa, durch +2 verweist auf 0xcd für weitere operation

aber wieso bleibt es auf 0xaa danach,nicht auf 0xcd
weil p+2 gibt nur den wert,pointer bleibt auf dem alten platz?