pointer und operanden hilfe

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?

Wenn du "normale" Variablen hast
int a = 5;
int b = a + 2;

Welchen Wert hat dann a? Da zweifelst du doch auch nicht, dass der auf 5 bleibt.

Zeiger sind auch Variable.
Die enthalten halt keine Ganzzahl oder Zeichen oder Fließkommazahl sondern eine Adresse.

Das p+2 ergibt nur eine Zwischenadresse. An den Wert an der Adresse kommst du mit dem Dereferenzierungsoperator * . Darum *(p+2)

sanek

und p++ ist nicht gleich p+1 ?
für pointer

SeppJ

sanek schrieb:

und p++ ist nicht gleich p+1 ?
für pointer

Egal ob für Pointer oder andere Typen: p++ gibt den Wert von p zurück und ändert den Wert von p zu p+1. p+1 gibt den Wert p+1 zurück, p bliebt unverändert. ++p gibt p+1 zurück, p bekommt den neuen Wert p+1.

Das gilt für Pointer und Ganzzahlvariablen.

Beim p+1 passiert weiter nichts mit p.

Beim p++ wird p erst nach der Verwendung in der Rechnung inkrementiert.

Beim ++p wird p vor der Verwendung inkrementiert. Mit diesem neuen Wert wird dann weiter gerechnet.

SeppJ

DirkB schrieb:

Ganzzahlvariablen.

Fließkommatypen auch. Damit hast du alles außer zusammengesetzten Typen.

edit: Pointer und enums gelten natürlich als zusammengesetzte Typen. Sagen wir: Skalare Typen. Ist zwar C++-Sprech, ich bin gerade zu faul um zu gucken, wie das im C-Standard heißt.

sanek

danke.alles klar