Warum ist ein Boolean so groß?

[Eichhoernchen]

Hab gerade mal im Wikipedia über Object Pascal gelesen.

Zitat:

Zitat von Wikipedi

ByteBool / Boolean 1 Byte true oder false boolescher Wert
WordBool 2 Byte true oder false boolescher Wert
LongBool 4 Byte true oder false boolescher Wert

Wozu ist es nötig das nen Boolean 1 byte groß ist?

Man muss doch nur 2 zustände darstellen, TRUE und FALSE also da würd doch sogar nen bit reichen?!

warum gibt es auch 4 byte große booleans und wo ist der Unterschied?

[Tubos]

Man kann in einem PC nur jedes Byte adressieren.

Zitat:

warum gibt es auch 4 byte große booleans und wo ist der Unterschied?

2 und 4 Byte große Bools wird es deshalb geben, damit die genau 2 oder 4 Byte groß sind.
Hoppla, erst nachdem ich den Satz geschrieben habe bin ich draufgekommen dass das keine wirkliche Begründung ist. Bevor ich vage Vermutungen äußere darf den Teil der Frage jemand anderer beantworten :zwinker:

[ripper8472]

weil du nur byteweise addressieren kannst!

was widebool fuern zweck hat, entzieht sich meiner logik... tja, delphi eben

[Oxmyx]

Einfach gesagt: 32 Bit große Typen werden von der CPU schneller verarbeitet.

Aus genau diesem Grund richtet Delphi die Strukturmitglieder standardmäßig auch auf 4 Byte aus:

Delphi-Quellcode:

  TTest = record
    a: Byte;
    b: Integer;
  end;

belegt standardmäßig nicht etwa 5 Byte, wie man vermuten würde, sondern 8 Byte, weil das einzelne Byte auf 32 Bit ausgerichtet wird.

[Eichhoernchen]

ahwas, okay macht Sinn das mit den Adresssierungen von Bytes, wäre ja auch ganz schön durcheinander wenn es bits wären die adressiert werden. Hmm und das mit den größeren scheint dann ja nur "geschwindigkeits"vorteile zu bringen?!

Naja also kann nen 4 byte bool auch nicht mehr als nen 2 byte großer, das reicht mir schon,

Aber wird der Delphi kompiler nicht ehh dann aus jedem 1 byte bool nen 4 byte(32bit) bool machen, wenn die CPU das besser verarbeiten kann? wie schaut es bei 64 bit prozessoren aus? oder hat das jetzt gar nix damit zu tun? Ich kenne mich in dem Bereich nicht so gut aus. wäre da nen 8byte bool besser als nen 4er?


Die hab ja einen an der Waffel bei Borland ;) 4 byte Bools, wo kommen wir noch hin....



Eichhoernchen

[himitsu]

Man kann Booleans auch Incrementieren und Decrementieren.

Delphi-Quellcode:

Var B: Boolean/ByteBool/WideBool/LongBool;  // geht bei allen

Inc(B);
Dec(B);

Die Booleans sind ja so definiert:

Code:

True:   B <> 0
False:  B = 0

Und die Standard-Konstanten:

Code:

True  = 1
False = 0

Also:

Delphi-Quellcode:

Var B: Boolean/ByteBool;

B := False;  // 0 > False
Inc(B);      // 1 > True
Inc(B);      // 2 > True
Dec(B);      // 1 > True
Dec(B);      // 0 > False
Dec(B);      // 255 > True

Man kann es also z.B. zum Sperren von irgendwas verwenden, wenn z.B. dieses von mehreren Prozessen gesperrt werden soll und nur wieder freigegeben soll, wenn es auch wieder von allen Prozessen freigegeben wurde.

Delphi-Quellcode:

Var gesperrt: ByteBool/Boolean;

gesperrt := False;  // 0: initialasieren = freigegeben
Inc(gesperrt);      // 1: sperren   = gesperrt
Inc(gesperrt);      // 2: sperren   = gesperrt
Dec(gesperrt);      // 1: freigeben = gesperrt
Inc(gesperrt);      // 2: sperren   = gesperrt
Dec(gesperrt);      // 1: freigeben = gesperrt
Dec(gesperrt);      // 0: freigeben = freigegeben

wobei die Richtung in diesem Fall eigentlich sogar egal ist:

Delphi-Quellcode:

gesperrt := False;  // 0:   initialasieren = freigegeben
Dec(gesperrt);      // 255: sperren   = gesperrt
Dec(gesperrt);      // 254: sperren   = gesperrt
Inc(gesperrt);      // 255: freigeben = gesperrt
Dec(gesperrt);      // 254: sperren   = gesperrt
Inc(gesperrt);      // 255: freigeben = gesperrt
Inc(gesperrt);      // 0:   freigeben = freigegeben

Und abfragen kann man dieses ja dann ganz einfach so:

Delphi-Quellcode:

If gesperrt Then ...

[add]
PS:

in Delphi: Boolean = ByteBool
und in Windows/C++: BOOL = LongBool

die WinAPI-Funktionen verwenden alle das LongBool (32-Bit)


[add2]
Ach ja, geschwindigkeitsvorteil gibt es auch nicht immer.

z.B. dürfte

Delphi-Quellcode:

Var B: Boolean/ByteBool;
B := True;

schneller sein als

Delphi-Quellcode:

Var B: LongBool;
B := True;

(wenn ihr euch mal den Befehl in ASM anseht, dann werdet ihr merken, daß der 32-Bit-Befehl größer ist)

[Mystic]

Zitat:

Zitat von Oxmyx

Einfach gesagt: 32 Bit große Typen werden von der CPU schneller verarbeitet.

Aus genau diesem Grund richtet Delphi die Strukturmitglieder standardmäßig auch auf 4 Byte aus:

Delphi-Quellcode:

  TTest = record
    a: Byte;
    b: Integer;
  end;

belegt standardmäßig nicht etwa 5 Byte, wie man vermuten würde, sondern 8 Byte, weil das einzelne Byte auf 32 Bit ausgerichtet wird.

Und packed record hebt die Ausrichtung wieder auf:

Delphi-Quellcode:

  TTest = packed record
    a: Byte;
    b: Integer;
  end;

Und sorgt so dafür dass dieser record auch nur 5 Byte groß ist.

[SMO]

Zitat:

Zitat von Oxmyx

Einfach gesagt: 32 Bit große Typen werden von der CPU schneller verarbeitet.

Aus genau diesem Grund richtet Delphi die Strukturmitglieder standardmäßig auch auf 4 Byte aus:

Delphi-Quellcode:

  TTest = record
    a: Byte;
    b: Integer;
  end;

belegt standardmäßig nicht etwa 5 Byte, wie man vermuten würde, sondern 8 Byte, weil das einzelne Byte auf 32 Bit ausgerichtet wird.

Das stimmt so nicht ganz. Nicht das Byte "a" wird ausgerichtet, sondern der Integer "b". Delphi richtet die Felder eines nicht-gepackten Records so aus, dass ein Feld der Größe X Bytes an einer Speicheradresse beginnt, die ohne Rest durch X teilbar ist (für X = 1, 2, 4, 8 ). Wandeln wir mal dein Beispiel etwas ab:

Delphi-Quellcode:

  TTest = record
    a: Byte;
    b: Int64;
  end;

Delphi fügt jetzt nicht 3 Bytes sondern 7 Bytes hinter "a" ein, damit "b", welches 8 Bytes groß ist, an einer Speicheradresse beginnt, die durch 8 teilbar ist. SizeOf(TTest) wäre somit nicht mehr 8 sondern 16.

Zitat:

Zitat von Eichhoernchen

Hmm und das mit den größeren scheint dann ja nur "geschwindigkeits"vorteile zu bringen?!

Aber wird der Delphi kompiler nicht ehh dann aus jedem 1 byte bool nen 4 byte(32bit) bool machen, wenn die CPU das besser verarbeiten kann? wie schaut es bei 64 bit prozessoren aus? oder hat das jetzt gar nix damit zu tun? Ich kenne mich in dem Bereich nicht so gut aus. wäre da nen 8byte bool besser als nen 4er?

Im Falle der Ausrichtung wie oben erwähnt, ja. Wenn eine Variable, die mehrere Bytes groß ist, nicht richtig ausgerichtet ist (z.B. ein 16 Bit Word, das an einer ungeraden Speicheradresse beginnt), muss die CPU unter Umständen zwei Speicherzugriffe tätigen, um die Variable einmal zu lesen. Das sollte natürlich vermieden werden.

Was die Größe der Bools betrifft: meines Wissens stimmt es schon, dass Datentypen in der "nativen" Größe einer CPU vorzuziehen sind (wenn man nicht gerade Speicher sparen muss). Eine 8-Byte-Bool Variable könnte also durchaus die beste Wahl auf einer 64 Bit CPU sein. Aber ob z.B. ein LongBool nun in der Praxis (auf einem 32 Bit Prozessor) wirklich schneller ist als ein 8 Bit Boolean, weiß ich nicht (ich zweifle). Sollte jemand mal genau messen. :)

Zitat:

Die hab ja einen an der Waffel bei Borland ;) 4 byte Bools, wo kommen wir noch hin....

Wie himitsu bereits schrieb, das ist nicht auf Borlands Mist gewachsen. ;)

Zitat:

Zitat von himitsu

Die Booleans sind ja so definiert:

Code:

True:   B <> 0
False:  B = 0

Und die Standard-Konstanten:

Code:

True  = 1
False = 0

in Delphi: Boolean = ByteBool

Ich glaube das stimmt nicht ganz. True = 1 gilt nur für Boolean. Für Byte/Word/LongBool ist True = -1. Es gibt also einen feinen Unterschied zwischen Boolean und ByteBool.
Zum Testen:

Delphi-Quellcode:

procedure BoolTest;
var
  B0: Boolean;
  B1: ByteBool;
  B2: WordBool;
  B3: LongBool;
begin
  B0 := True;
  B1 := True;
  B2 := True;
  B3 := True;
  ShowMessage(Format('B0 = %d'#10'B1 = %d'#10'B2 = %d'#10'B3 = %d',
    [Ord(B0), Ord(B1), Ord(B2), Ord(B3)]));
end;

[himitsu]

Könntest recht haben ... laut MS sind bei TRUE alle Bit's gesetzt ... sowas kommt davon, wenn man zuviel mit den Borland's eigenen Typen rummacht -.-''
(muß i glei ma gucken, ob'sch das och überall richtig gemacht hab)

Blöd nur, wenn man diese Tatsache zwar irgendwie im Hinterkopf hat, das einam aber dennoch nicht wirklich auffällt, aber dank dir ist's mir jetzt wie Schuppen auf den Haaren gefallen :mrgreen:

[Robert Marquardt]

Ein Byte ist die kleinste von jedem Prozessor zu adressierende Einheit.
Es hat also keinen Zweck Boolean kleiner zu machen. Man koente es auf einigen Prozessoren nicht mehr adressieren.

WordBool und LongBool sind Typen zur Unterstuetzung des Windows API.
In C gibt es keinen Boolean Typ. Dort gilt alles ungleich Null als True und Null als False.
Entsprechend liefern viele Win32-Funktionen faktisch einen LongBool.