C++ Operator |= in Delphi

[Anthrox]

Liebe DP!
Erstmal, ich bin mir nicht ganz sicher ob ich jetzt das richtige Forum erwischt habe aber diese Frage schien mir sonst nirgends besser zu passen :stupid:

Also dann zu meinem Problem:

Ich versuche gerade ein Tutorial (C++) für Hardware Breakpoint Hooks nachzuvollziehen. (Wen es interessiert: Link)
Das ganze ging auch relativ gut aber nun bin ich hier stecken geblieben:

Code:

// Erster HW BP
ctx.Dr0 = 0xADRESSE1;
ctx.Dr7 = 0x00000001;

// Zweiter HW BP
ctx.Dr1 = 0xADRESSE2;
ctx.Dr7 |= 0x00000004;

[..]

Code:

ctx.Dr7 |= 0x00000004;

Das hier verstehe ich nicht wirklich.
Ich habe mal gegoogelt

Zitat:

Kombinierte Zuweisungsoperatoren

Die kombinierten Zuweisungsoperatoren kombinieren den Zuweisungsoperator (=) mit einem anderen Operator:
[..]

• |=

Dabei wird der linke Operator sowohl als linker Operator für die Zuweisung als auch für den anderen Operator verwendet.

Wie das beispielsweise mit += funktioniert verstehe ich :-D
Aber ich begreife einfach nicht wie ein or (|) mit einem = verknüpft werden kann.
Weiss da jemand von euch Rat?

Liebe Grüsse Anthrox

[Assarbad]

Delphi-Quellcode:

ctx.Dr1 := ctx.Dr1 or $ADRESSE2;

Hinweis: in Delphi gibt es keine Unterscheidung zwischen bitweisen (|, &) und logischen (||, &&) Operatoren wie in C-Sprachen.

[Namenloser]

Delphi-Quellcode:

a += b

ist eine Kurzform für

Delphi-Quellcode:

a = a+b

Delphi-Quellcode:

a -= b

ist eine Kurzform für

Delphi-Quellcode:

a = a-b

Delphi-Quellcode:

a *= b

ist eine Kurzform für

Delphi-Quellcode:

a = a*b

Delphi-Quellcode:

a /= b

ist eine Kurzform für

Delphi-Quellcode:

a = a/b

usw...
dementsprechend ist

Delphi-Quellcode:

a |= b

ist eine Kurzform für

Delphi-Quellcode:

a = a | b

, also in Delphi:

Delphi-Quellcode:

a := a or b

.

[Anthrox]

Na dann, vielen Dank euch beiden.
Aber eine Frage bleibt mir noch..
Wozu braucht man denn bei einer Zuweisung ein or? :gruebel:
Ich verstehe ja dass das ganz nützlich sein kann bei einer if-Abfrage aber ich sehe den Sinn bei einer Zuweisung irgendwie nicht.
Welcher von den beiden Werten wird denn schlussendlich geschrieben? Beziehungsweise, wie funktioniert dieser Operator bei einer Zuweisung überhaupt?

lg Anthrox

[mkinzler]

Or ist eine Booleanoperator:

0 or 0 = 0
0 or 1 = 1
1 or 0 = 1
1 or 1 = 1

[Assarbad]

Zitat:

Zitat von Anthrox (Beitrag 1083658)

Aber eine Frage bleibt mir noch..
Wozu braucht man denn bei einer Zuweisung ein or? :gruebel:

Weil du bspw. in der Variablen auf der linken Seite der Zuweisung ein Flag setzen willst.

Zitat:

Zitat von Anthrox (Beitrag 1083658)

Ich verstehe ja dass das ganz nützlich sein kann bei einer if-Abfrage aber ich sehe den Sinn bei einer Zuweisung irgendwie nicht.

Bei einem if dann aber ohne Zuweisung ;) (üblicherweise).

Zitat:

Zitat von Anthrox (Beitrag 1083658)

Welcher von den beiden Werten wird denn schlussendlich geschrieben? Beziehungsweise, wie funktioniert dieser Operator bei einer Zuweisung überhaupt?

Siehe oben von NamenLozer.

Beispiel

Code:

// a ist eine Variable
// b ist eine Konstante
a |= b;

... a enthält nun die bitweise Kombination aus (a or b).

[Anthrox]

Zitat:

Zitat von Assarbad (Beitrag 1083662)

Zitat:

Zitat von Anthrox (Beitrag 1083658)

Aber eine Frage bleibt mir noch..
Wozu braucht man denn bei einer Zuweisung ein or? :gruebel:

Weil du bspw. in der Variablen auf der linken Seite der Zuweisung ein Flag setzen willst.

Zitat:

Zitat von Anthrox (Beitrag 1083658)

Ich verstehe ja dass das ganz nützlich sein kann bei einer if-Abfrage aber ich sehe den Sinn bei einer Zuweisung irgendwie nicht.

Bei einem if dann aber ohne Zuweisung ;) (üblicherweise).

Zitat:

Zitat von Anthrox (Beitrag 1083658)

Welcher von den beiden Werten wird denn schlussendlich geschrieben? Beziehungsweise, wie funktioniert dieser Operator bei einer Zuweisung überhaupt?

Siehe oben von NamenLozer.

Beispiel

Code:

// a ist eine Variable
// b ist eine Konstante
a |= b;

... a enthält nun die bitweise Kombination aus (a or b).

Wenn ich ehrlich bin verstehe ich das nicht so ganz :oops:
Also, was für ein Flag wird da gesetzt? (irgendwie habe ich das Gefühl ich verstehe etwas falsch^^)

Zitat:

Zitat von mkinzler (Beitrag 1083661)

Or ist eine Booleanoperator:

0 or 0 = 0
0 or 1 = 1
1 or 0 = 1
1 or 1 = 1

Viele Danke :-D
Aber wie wäre dann das mit anderen Zahlen wie zum Beispiel
55 or 99
Mit 0 und 1 verstehe ich das ja.
Nur mit anderen Zahlen ist mir das ein Rätsel :gruebel:

Code:

  //HW BP Nummer 1//
  ctx.Dr0:= $ADDRESSE1;
  ctx.Dr7:= $00000001;
  //HW BP Nummer 2//
  ctx.Dr1:= $ADDRESSE2;
  ctx.Dr7:= ctx.Dr7 or $00000004;
  //HW BP Nummer 3//
  ctx.Dr2:= $ADDRESSE3;
  ctx.Dr7:= ctx.Dr7 or $00000010;
  //HW BP Nummer 4//
  ctx.Dr3:= $ADDRESSE4;
  ctx.Dr7:= ctx.Dr7 or 00000040;

Anhand dieses Beispiels, wieso macht man das?
Irgendwie will sich mir der Sinn davon nicht erschliessen...

[Namenloser]

Jede Zahl liegt im Computer binär vor. Beispiel:

Delphi-Quellcode:

3 or 9 = (00000011b or 00001001b) = (00001011b) = 11

[ADD]
Oder um bei deinem Beispiel zu bleiben:

Code:

      Dez. . Bin.
...    55     00110111
or...  99     01100011
=     119     01110111

Sry für die Füllzeichen (. und _), die Einrückung im Code-Block ist immer noch kaputt.

[Anthrox]

Zitat:

Zitat von NamenLozer (Beitrag 1083673)

Jede Zahl liegt im Computer binär vor. Beispiel:

Delphi-Quellcode:

3 or 9 = (00000011b or 00001001b) = (00001011b) = 11

Ahhhhhhhhhhhhh!

Code:

00000011
00001001
--------
00001011

Also so? Jede Ziffer wird einzeln verglichen und dann abgeändert?
Jetzt verstehe ich es :thumb:
Aber was das nützt ist mir noch immer schleierhaft :cry:
Denn schlussendlich erhält man ja einfach eine andere Zahl oder nicht?

[Namenloser]

Ja, genau so, hab deinen neuen Beitrag beim Editieren nicht gesehn.

Zum Nutzen: Man kann das verwenden, um in jedem Bit ein Boolean zu speichern, also insgesamt 8 Pro Byte. Das wird gern in Sprachen wie C genutzt, die keinen nativen Set-Datentyp haben wie Delphi. Man verwendet dann Zweierpotenzen als Maske zum Auslesen und Setzen der einzelnen Bits.

Wenn ich z.B. das 4 Bit von rechts setzen will, rechne ich einfach

Delphi-Quellcode:

OR 8

, weil 8 binär 00001000 ist. Auslesen geht dann umgekehrt mit

Delphi-Quellcode:

and

. Man gibt die Flags meist Hexadezimal an.

[Assarbad]

Sei mir nicht böse. Aber du schriebst:

Zitat:

Zitat von Anthrox (Beitrag 1083581)

Ich versuche gerade ein Tutorial (C++) für Hardware Breakpoint Hooks nachzuvollziehen. (Wen es interessiert: Link)

... und weißt nichts mit bitweisen und logischen Operatoren anzufangen? Das sind Grundlagen! Ich empfehle dir ganz stark ein Buch mit derlei Grundlagenwissen zu konsultieren.

Bevor man nämlich mit Registern rumspielt, sollte man wissen wie die CPU funktioniert (zumindest aus Software-Perspektive) und dazu muß man schon mindestens die genannten Operatoren beherrschen, sowie einige weitere ...

[Anthrox]

Zitat:

Zitat von Assarbad (Beitrag 1083678)

Sei mir nicht böse. Aber du schriebst:

Zitat:

Zitat von Anthrox (Beitrag 1083581)

Ich versuche gerade ein Tutorial (C++) für Hardware Breakpoint Hooks nachzuvollziehen. (Wen es interessiert: Link)

... und weißt nichts mit bitweisen und logischen Operatoren anzufangen? Das sind Grundlagen! Ich empfehle dir ganz stark ein Buch mit derlei Grundlagenwissen zu konsultieren.

Bevor man nämlich mit Registern rumspielt, sollte man wissen wie die CPU funktioniert (zumindest aus Software-Perspektive) und dazu muß man schon mindestens die genannten Operatoren beherrschen, sowie einige weitere ...

Naja, da hast du wohl recht :|
Ich habe mir auch schon überlegt ein gutes Buch zuzutun. (grässliches Wort :))
Du hast nicht zufällig einen guten Vorschlag?
Ich habe ein Buch aber da sind eben nur die grundlagigsten Grundlagen drinne :(
Naja, wie gesagt wenn du 'nen Vorschlag hast, her damit!

Zitat:

Zitat von NamenLozer (Beitrag 1083676)

Ja, genau so, hab deinen neuen Beitrag beim Editieren nicht gesehn.

Zum Nutzen: Man kann das verwenden, um in jedem Bit ein Boolean zu speichern, also insgesamt 8 Pro Byte. Das wird gern in Sprachen wie C genutzt, die keinen nativen Set-Datentyp haben wie Delphi. Man verwendet dann Zweierpotenzen als Maske zum Auslesen und Setzen der einzelnen Bits.

Wenn ich z.B. das 4 Bit von rechts setzen will, rechne ich einfach

Delphi-Quellcode:

OR 8

, weil 8 binär 00001000 ist. Auslesen geht dann umgekehrt mit

Delphi-Quellcode:

and

. Man gibt die Flags meist Hexadezimal an.

Und ich habe gar nicht gesehen dass du editiert hast :-D
Also ist das sozusagen eine kompliziertere Version von einem booleschen Wert? :lol:
(beziehungsweise mehrere boolesche Werte)

Ich weiss ja nicht aber verstehst du rein zufällig wieso das bei dem Beispiel von vorher gemacht wird?

Delphi-Quellcode:

  //HW BP Nummer 1//
  ctx.Dr0:= $ADDRESSE1;
  ctx.Dr7:= $00000001;
  //HW BP Nummer 2//
  ctx.Dr1:= $ADDRESSE2;
  ctx.Dr7:= ctx.Dr7 or $00000004;
  //HW BP Nummer 3//
  ctx.Dr2:= $ADDRESSE3;
  ctx.Dr7:= ctx.Dr7 or $00000010;
  //HW BP Nummer 4//
  ctx.Dr3:= $ADDRESSE4;
  ctx.Dr7:= ctx.Dr7 or 00000040;

$1 = 1b
$4 = 100b
sind wieder 100 binär richtig?

100b
10000b
sind wieder 10000 binär

10000b
1000000b
auch das sind wieder 1000000 binär

Wieso werden denn da nicht einfach die Werte zugewiesen, das ist ja gar nicht nötig wenn es wieder das gleiche gibt wie wenn man nichts macht :gruebel:

[Assarbad]

Bücher auf Deutsch oder darf's auch Englisch sein?

Zitat:

Zitat von Anthrox (Beitrag 1083682)

$1 = 1b
$4 = 100b
sind wieder 100 binär richtig?

Okay, was vielen Leuten hilft, ist es sich or als + vorzustellen. Das stimmt unter bestimmten Randbedingungen nicht mehr ganz, aber hier ist es sogar anschaulich. Aber erstmal erklären wir Nibbles.

Ein Nibble sind 4bit, also ein halbes Oktett (Oktette werden üblicherweise als Bytes bezeichnet).

Nun zur Korrelation der Werte:

Code:

binär | hexadezimal  | dezimal
------------------------------
0000  |      $0     |     0
0001  |      $1     |     1
0010  |      $2     |     2
0011  |      $3     |     3
0100  |      $4     |     4
0101  |      $5     |     5
0110  |      $6     |     6
0111  |      $7     |     7
1000  |      $8     |     8
1001  |      $9     |     9
1010  |      $A      |    10
1011  |      $B      |    11
1100  |      $C      |    12
1101  |      $D      |    13
1110  |      $E      |    14
1111  |      $F      |    15

Über diese Tabelle kannst du selbst im Kopf einfach von/nach binär umrechnen. Wir wissen nämlich nun, daß eine Hexadezimalstelle vier Binärstellen entspricht. Beispiel:

Code:

$ABCDEF
 ||||||__ 1111
 |||||___ 1110
 ||||____ 1101
 |||_____ 1100
 ||______ 1011
 |_______ 1010

Leserichtung "nach oben", also 10101011.11001101.11101111.

Zitat:

Zitat von Anthrox (Beitrag 1083682)

Wieso werden denn da nicht einfach die Werte zugewiesen, das ist ja gar nicht nötig wenn es wieder das gleiche gibt wie wenn man nichts macht :gruebel:

In deinem oben zitierten Fall will man eben folgendes erreichen, hier am Beispiel:

Delphi-Quellcode:

  ctx.Dr3:= $ADDRESSE4;
  ctx.Dr7:= ctx.Dr7 or $00000040;

ctx.Dr7 hat bereits irgendeinen Wert. Es ist für uns unwichtig, aber wir wollen das Bit setzen welches durch $00000040 repräsentiert wird - man nennt das Bitmaske. Wenn wir in unserer Tabelle nachschauen, sehen wir:

Code:

$40 == 01000000

Da man bei Bits von 0 und von "hinten" zu zählen beginnt

Code:

0 1 0 0 0 0 0 0
| | | | | | | |
7 6 5 4 3 2 1 0
  *

wollen wir also Bit 6 setzen ohne die anderen Bits zu beeinflussen. Deswegen hier ein bitweises Oder.

Hier ein paar Beispiele für den Wert in Dr7 davor und danach. Wobei wir hier der Einfachheit halber nur die unteren beiden Nibble (also die unteren 8 Bit) betrachten). Alles binär:

Code:

[Dr7]     or 01000000 == ...
----------------------------
00000000 or 01000000 == 01000000
00000001 or 01000000 == 01000001
00010001 or 01000000 == 01010001
00010010 or 01000000 == 01010010
00100010 or 01000000 == 01100010
00100011 or 01000000 == 01100011
00110011 or 01000000 == 01110011
00110100 or 01000000 == 01110100
01000100 or 01000000 == 01000100
01000101 or 01000000 == 01000101
01010101 or 01000000 == 01010101
01010110 or 01000000 == 01010110
01100110 or 01000000 == 01100110
01100111 or 01000000 == 01100111
01110111 or 01000000 == 01110111
01111000 or 01000000 == 01111000
10001000 or 01000000 == 11001000
10001001 or 01000000 == 11001001
10011001 or 01000000 == 11011001
10011010 or 01000000 == 11011010
10101010 or 01000000 == 11101010
10101011 or 01000000 == 11101011
10111011 or 01000000 == 11111011
10111100 or 01000000 == 11111100
11001100 or 01000000 == 11001100
11001101 or 01000000 == 11001101
11011101 or 01000000 == 11011101
11011110 or 01000000 == 11011110
11101110 or 01000000 == 11101110
11101111 or 01000000 == 11101111
11110000 or 01000000 == 11110000
11111111 or 01000000 == 11111111

Da unsere Bitmaske $40 nur ein gesetztes Bit hat, wird auch nur dieses beeinflußt. Entsprechend ändert sich im Ergebnis nur Bit 6.

[Deep-Sea]

Zitat:

Zitat von Anthrox (Beitrag 1083682)

$1 = 1b
$4 = 100b
sind wieder 100 binär richtig?

100b
10000b
sind wieder 10000 binär

[...]

Denk dir das mal gerade als dezimale Zahlen, die du addieren willst.
Deiner Logik zu folge wäre dann 1 + 100 = 200 :stupid: Das stimmt natürlich nicht, da die 1 ja die gleiche Wertigkeit wie die rechte 0 in 100 hat. Du musst es rechtsbündig ausrichten:

Code:

$1 = __1b or
$4 = 100b =
$5 = 101b

Nun, was kommt jetzt bei 100b or 10000b raus? :wink:

[Anthrox]

Ich kenne kaum ein Forum in dem die Leute einem einfach so soviel, so gut erklären wie hier :dp:

@Assarbad Zu den Büchern: Vorzugsweise Deutsch aber wenn du etwas besseres in Englisch kennst geht das auch :-D
Ich glaube jetzt habe ich es verstanden.
Zuerst wird

Delphi-Quellcode:

ctx.Dr7:= $00000001;

einfach ein Wert zugewiesen.
Dann

Delphi-Quellcode:

ctx.Dr7:= ctx.Dr7 or $00000004;

Code:

00000001
00000100
--------
00000101

weiter..

Delphi-Quellcode:

ctx.Dr7:= ctx.Dr7 or $00000010;

Code:

00000101
00010000
--------
00010101

noch weiter..

Delphi-Quellcode:

ctx.Dr7:= ctx.Dr7 or 00000040;

Code:

00010101
01000000
--------
01010101

Aber der Wert den Dr7 schlussendlich enthält, der zeigt dann welche Hardwarebreakpoints benutzt werden? (also auf 1)
Ich denke ich habe es nun begriffen, vielen Dank für die ausführlichen Erklärungen.:)

@Deep-Sea Da habe ich wohl einen groben Fehler gemacht :?
Aber so wie du es erklärst klingt es logisch!

[Assarbad]

Zitat:

Zitat von Anthrox (Beitrag 1083746)

Aber der Wert den Dr7 schlussendlich enthält, der zeigt dann welche Hardwarebreakpoints benutzt werden? (also auf 1)

Genau so ;)

[Assarbad]

Wurde heute gerade hier im Forum verlinkt: http://www.delphipraxis.net/95180-ef...bitmasken.html

Sollte ein wenig beim Verständnis helfen wo es jetzt vielleicht noch mangelt.

[Anthrox]

Okay, das werde ich mir bestimmt mal durchlesen :-D
Hast du noch Vorschläge für gute Bücher?
Denke mal das mit den Bitmasken ist nicht das einzige was ich verpasst habe, ohne ein gutes Buch :?