Im Quelltext auftretende Zahlen interpretiert FreeBASIC zunächst als Dezimalzahlen. So, wie oben die tiefgestellten Werte verwendet wurden, um das verwendete Zahlensystem zu kennzeichnen (wie D₁₆ für das Hexadezimalsystem), muss es auch im Programm explizit kenntlich gemacht werden, wenn Sie nicht das Dezimalsystem meinen. FreeBASIC verwendet dazu die et-Ligatur &, die, zusammen mit einem Kennbuchstaben für das gewünschte System, vor die Zahl geschrieben wird:

Sowohl für den Kennbuchstaben als auch die Ziffern A-F im Hexadezimalsystem ist Groß- und Kleinschreibung nicht von Bedeutung.

Mit dieser neuen Schreibweise können Zahlen anderer Systeme genauso im Programm verwendet werden, wie Sie es von Dezimalzahlen gewohnt sind. Nur Gleitkommazahlen anderer Systeme sind in FreeBASIC nicht möglich.

FreeBASIC selbst zeigt Zahlen ausschließlich im Dezimalsystem an. Wenn Sie eine Anzeige in einem anderen Zahlensystem wünschen, kann diese nur über einen String erfolgen. Die Umwandlung läuft über die Funktionen BIN() (Binärsystem), OCT() (Oktalsystem) und HEX() (Hexadezimalsystem). Der Rückgabewert ist ein String, der die Ziffernfolge im jeweiligen System enthält. BIN() wurde ja schon in Kapitel 10.2 eingesetzt.

Wenn Sie übrigens den Zahlenwert als WSTRING haben wollen, verwenden Sie stattdessen die Funktionen WBIN(), WOCT() und WHEX(). Wir werden uns allerdings erst einmal weiter mit normalen Strings beschäftigen.

Wenn Sie nachrechnen wollen: Für das Binärsystem ergibt sich 32+8+2 = 42, im Oktalsystem 5·8+2 = 42 und im Hexadezimalsystem 2·16+10 = 42. Interessant ist sicher auch der Umgang mit negativen Zahlen:

Beim Wert -1 sind alle Bits gesetzt, das entspricht (in einem 32-Bit-System) der maximalen Oktalzahl 37777777777 bzw. der maximalen Hexadezimalzahl FFFFFFFF. Für jeden Schritt weiter ins Negative wird dieser Maximalwert um 1 reduziert.

BIN(), OCT() und HEX() erlauben einen zusätzlichen zweiten Parameter, der die Länge des zurückgegebenen Strings angibt. Das kann genutzt werden, um ihn vorn bei Bedarf mit Nullen aufzufüllen und dadurch eine einheitliche Länge zu erhalten, aber auch, um führende Ziffern abzuschneiden, die für Sie nicht interessant sind.

BIN(-x) würde, je nach System, 32 oder 64 Stellen ausgeben. Da Sie aber mit einem UBYTE arbeiten, sind für Sie vermutlich nur die hintersten acht Ziffern von Belang.

Da die mit BIN() usw. zurückgegebenen Werte Zeichenketten sind, können Sie mit ihnen natürlich nicht einfach so weiterrechnen. Das ist allerdings nicht schlimm, da sich die Berechnungen in anderen Zahlensystemen nicht voneinander unterscheiden; es handelt sich lediglich um eine andere Darstellungsform der Werte bzw. der Ergebnisse. Sie können also getrost die Rechnung im Dezimalsystem durchführen (tatsächlich nutzt der Prozessor intern ja das Binärsystem) und das Ergebnis in das von Ihnen gewünschte System umwandeln.

Um mit Zahlen, die nach der Verwendung von BIN() usw. in einem String vorliegen, weiterzurechnen, können Sie sie mit CINT() (oder einer anderen Funktion aus dieser Gruppe) in das Dezimalsystem umwandeln. Beachten Sie aber, dass die Information, um welches System es sich aktuell handelt, im String nicht gespeichert wurde. Sie müssen sie also wieder „nachtragen“, und zwar wie oben durch ein & und den Kennbuchstaben, die vor dem Zahlenwert eingefügt werden müssen.

Dem Binärzahl-String wird also vorn ein "&b" angefügt und das Ganze dann in die Funktion CINT() eingefügt.

Für Oktalzahlen erlaubt FreeBASIC hier — und nur hier — auch das Weglassen des Kennbuchstaben o. Die et-Ligatur allein würde reichen. Mit dem o wird es jedoch deutlicher, welches Zahlensystem genau gemeint ist.

In Kapitel 10.2.4 wurde bereits das Verhalten der Operatoren AND, OR, XOR usw. besprochen. Diese können gezielt dazu verwendet werden, den Status bestimmter Bits abzufragen. Ein einfacher Fall ist die bereits in Kapitel 14.1.5 angedachte Überprüfung, ob eine Zahl gerade ist. Da bei ungeraden Zahlen das niedrigste Bit gesetzt ist und bei geraden Zahlen nicht, kann man die Geradzahligkeit auch über AND prüfen.

Hilfreich sind die Bitoperatoren, wenn die einzelnen Bit einer Zahl jeweils eigene Informationen ausdrücken sollen. Nehmen wir als Beispiel eine Variable, die verschiedene Anzeigeoptionen eines Textes beinhalten soll. Wir legen (willkürlich) fest, dass Bit 0⁵ angibt, ob der Text fett gedruckt sein soll. Bit 1 gibt eine Unterstreichung des Textes an, Bit 2 eine Kursivschrift. In Dezimalwerten ausgedrückt heißt das dann 1=fett, 2=unterstrichen, 4=kursiv. Kombinationen lassen sich durch eine Verknüpfung mehrerer Werte erreichen, z. B. 3=fett+unterstrichen, 6=unterstrichen+kursiv und 7=alle Attribute.

Ich habe hier bewusst allgemein von Verknüpfung gesprochen und nicht von Addition. Denn auch wenn der Wert für fett+unterstrichen durch die Addition von fett und unterstrichen entsteht, würde eine Addition von fett und fett den Wert unterstrichen ergeben — was natürlich keinen Sinn ergibt. Stattdessen kann die OR-Verknüpfung eingesetzt werden.

Hier weicht die Verknüpfungslogik vom allgemeinen Sprachgefühl des Alltags ab. Wenn die Formatierung auf fett UND kursiv gesetzt werden soll, werden die zugehörigen Zahlen mit OR verknüpft. Das mag auf den ersten Blick verwirren. Sie sollten sich jedoch klar machen, dass AND und OR auf Bit-Ebene arbeiten und dass OR im Ergebnis immer dann ein Bit setzt, wenn bei mindestens einem der Operanden das Bit gesetzt ist. 1 OR 4 setzt daher Bit 0 (wegen der 1) und Bit 2 (wegen der 4).

AND dagegen prüft, welche Bit bei beiden Operanden gleichzeitig gesetzt sind. Mit formatierung AND 2 können Sie feststellen, ob das Bit für die Unterstreichung gesetzt ist oder nicht, unabhängig davon, wie die anderen beiden Formatierungsarten eingestellt sind. Sie können auch prüfen, ob z. B. fett und kursiv gleichzeitig aktiviert sind oder ob beide deaktiviert sind — oder vieles mehr.

Bevor wir dazu ein Beispiel ansehen, gibt es noch einen Verbesserungsvorschlag zur Lesbarkeit. Da das Programm sehr kurz ist, kann man sich die Zuordnung 1=fett usw. noch recht gut merken. Bei größeren Projekten und längerer Entwicklungsdauer kann das aber schon schwierig werden, gerade weil Sie mit der Zeit sicher auch noch andere Werte aus anderen Bereichen ins Programm einführen, deren Bedeutungen man sich alle merken müsste. Stattdessen ist es einfacher, die Werte in Konstanten mit sprechenden Namen abzulegen.

Da Fettschrift schon von Beginn an aktiviert ist, darf sich durch eine „nachträgliche“ Aktivierung nichts ändern. Mit OR ist das kein Problem, während eine Addition von FETT zu einem völlig falschen Ergebnis geführt hätte. Sie sehen in Quelltext 14.13 übrigens, dass auch für die Bitoperatoren die Kurzschreibweise OR= usw. zulässig ist.

Sie sehen, dass man mit logischen Operatoren eine ganze Menge anstellen kann, allerdings dauert es vielleicht anfangs eine Weile, bis man sich an die Arbeitsweise gewöhnt hat. Um effektiv programmieren zu können, ist allerdings das Verständnis der Bitmanipulationen unerlässlich.

Um — unabhängig von der aktuellen Einstellung — eine der Formatierungsbefehle umzustellen, bietet sich XOR an. Zur Erinnerung: XOR setzt im Ergebnis genau dann ein Bit, wenn sich die beiden entsprechenden Bit der beiden Operatoren unterscheiden, also genau dann, wenn es in einem der beiden Operatoren gesetzt ist und im anderen nicht.

Auch wenn Bitfelder meist einfacher in der Handhabung sind, gibt es doch Gründe für den Einsatz der Bitoperatoren. Um Bitfelder zu verwenden, ist die Deklaration eines UDTs nötig, und das gleichzeitige Setzen mehrerer Formatangaben wäre nicht möglich. Wenn Sie etwa ein Unterprogramm einsetzen wollen, dem die gewünschte Formatierung übergeben werden soll, ist es deutlich leichter, diese schnell über einen Zahlenwert zusammenzusetzen, als zuerst das passende UDT zu bauen (auch dazu gibt es aber programmiertechnische Lösungen). Ein schlagendes Argument ist aber die bessere Kompatibilität zu anderen Programmiersprachen, da Ganzzahldatentypen in nahezu jeder Sprache zur Verfügung stehen.

Wenn Sie gezielt ein einzelnes Bit auslesen wollen, kommt auch der Befehl BIT() infrage.

Die Nummerierung der Bits beginnt wie üblich bei 0 für das niederste Bit. Die Funktion gibt -1 (=wahr) zurück, wenn das Bit gesetzt ist, und 0, wenn das nicht der Fall ist. Um ein bestimmtes Bit zu setzen, dient BITSET(), um es zu löschen (also auf 0 zu setzen) BITRESET().

Beachten Sie, dass BITSET() und BITRESET() nicht den Variablenwert selbst verändern, sondern lediglich den Wert zurückgeben, der durch die Veränderung entsteht. Wollen Sie in der Variablen selbst ein Bit verändern, müssen Sie das Ergebnis von BITSET() bzw. BITRESET() wieder der Variablen zuweisen.

Die in Quelltext 14.13 eingesetzte Einstellung von Formatangaben lässt sich mit den drei Befehlen ebenfalls umsetzen. Da nun die Position des Bits gefragt ist und nicht seine Wertigkeit, geht die Nummerierung nun von 0 bis 2 statt über die Werte 1, 2 und 4. Deswegen lässt sich hier sehr gut ENUM einsetzen. Ein Vorteil ist zudem, dass möglicherweise später neu hinzukommende Formateigenschaften nur zur Liste hinzugefügt werden müssen, ohne eine Berechnung der Wertbelegung vornehmen zu müssen.

Die Ausgabe ist identisch mit der Ausgabe zu Quelltext 14.13.

Beide Varianten — Bitoperatoren und BITSET()/BITRESET() — haben ihre Vorteile. Bitoperatoren sind nicht nur auf 1-Bit-Werte beschränkt, und es ist auch ein gleichzeitiger Zugriff auf mehrere Formatangaben möglich. Auf der anderen Seite ist das Setzen eines einzelnen Bits mit BITSET() deutlich anschaulicher. Auch das Löschen eines Bits mit Bitoperatoren sieht recht umständlich aus, während es mit BITRESET() sehr klar ist. Wenn Sie allerdings die Bitrechnung beherrschen, stellt auch das kein großes Problem dar.

Ähnlich wie BIT(), aber auf einen größeren Datenbereich bezogen, wirkt LOBYTE(). Wie der Name andeutet, wird hier nicht ein Bit-, sondern ein Byte-Zustand abgefragt, und zwar das untere Byte der übergebenen Zahl (LOw: niedrig). LOBYTE(zahl) ist identisch mit zahl AND &hFF, d. h. alles außer den unteren acht Bit (oder eben des unteren Byte) der Zahl wird ignoriert. Die eng verwandte Funktion HIBYTE() (HIgh: hoch) gibt das Byte oberhalb des LOBYTE() zurück.

Wenn mit Byte-Zuständen gearbeitet wird, verwendet man gern das Hexadezimalsystem, da dort ein Byte genau aus zwei Ziffern besteht. Hexadezimal gesprochen sind LOBYTE() die untersten zwei Ziffern und HIBYTE() die beiden Ziffern links davon.

Noch größere Bereiche decken LOWORD() und HIWORD() ab. Ein Word bzw. Datenwort ist eine Dateneinheit von zwei Byte. Wie sich jetzt leicht erschließen lässt, enthält ein LOBYTE() die unteren beiden Byte des übergebenen Parameters und HIBYTE() die zwei Byte darüber.

Falls sich das noch etwas kompliziert anhört — ein Beispiel sollte hier Klarheit schaffen.

Es gibt noch zwei Operatoren, die eigentlich in den Bereich der mathematischen Operatoren fallen, aber vorwiegend zur Bit-Manipulation eingesetzt werden: SHL (SHift Left) schiebt in einer Ganzzahl alle Bit um eine angegebene Anzahl an Stellen nach links, SHR (SHift Right) schiebt sie nach rechts.

An einem konkreten Beispiel bedeutet das: Die Zahl 27 hat die Binärdarstellung 110112. Schiebt man alle Bit um eins nach links, erhält man 1101102 bzw. die Dezimalzahl 54. Schiebt man dagegen alle Bit um eins nach rechts, erhält man 11012 bzw. die Dezimalzahl 13. Ein Bit, das „über den Rand hinaus“ geschoben wird, verschwindet also — und zwar auch bei SHL, wenn der Datentyp, in dem das Ergebnis gespeichert werden soll, zu klein ist.

Die Syntax für SHL (und selbstverständlich analog dazu auch für SHR) sieht folgendermaßen aus:

Ausgangswert ist der Wert, für den die Verschiebung stattfinden soll, und Anzahl ist die Zahl der Stellen, um die verschoben werden soll. In der Kurzschreibweise +SHL=+ wird der Wert des Ergebnisses direkt wieder in der Ausgangszahl gespeichert; ansonsten verändern SHL und SHR den Wert ihrer Operanden nicht. Natürlich können die Operatoren auch in Berechnungen eingebaut werden, ebenso wie z. B. der Operator + oder OR.

Tatsächlich erreichen Sie mit SHL dasselbe wie bei der Multiplikation mit einer Zweierpotenz und mit SHR entsprechend dasselbe wie bei der Ganzzahl-Division. Allerdings arbeiten SHL und SHR in der Regel schneller. Bei der Verwendung vorzeichenbehafteter Typen und einer Verschiebung über die Datentypgrenzen ist das Ergebnis möglicherweise überraschend, aber auch hier unterscheidet es sich nicht vom Ergebnis einer passenden Multiplikation.

Da in Quelltext 14.16 alle zur Berechnung verwendeten Werte Konstanten sind, kann der Compiler schon während der Compilierzeit feststellen, dass in Zeile 11 und Zeile 13 über den verfügbaren Bereich hinausgeschoben wird, also dass das Ergebnis zu groß ist, um in ein BYTE bzw. UBYTE zu passen. In diesem Fall gibt der Compiler eine Warnung aus. Der Code wird trotzdem compiliert und kann anschließend ausgeführt werden, trotzdem sollten Sie auf Warnungen des Compilers achten (und sie am besten beheben).