Zahlensysteme
Wir sind es uns gewohnt, im sogenannten Dezimalsystem zu rechnen, also mit den Ziffern 0 bis 9. Im Computer ist es jedoch nicht so einfach, mit diesen Zahlen umzugehen, da ein Computer bekanntlich nur mit den beiden Ziffern Null und Eins (Strom oder nicht Strom) rechnen kann. Dieses System nennt man das Binärsystem (bi kommt aus dem griechischen oder lateinischen und steht allgemein für zwei, doppelt, beide...).
Wie aber rechnet man mit bloss zwei Ziffern 0 und 1? Dazu ein kleiner Ausflug in die Mathematik:
Wenn wir im normalen Dezimalsystem eine Zahl aufschreiben, beispielsweise 456, so kann diese Zahl aufgeteilt werden in Hunderter, Zehner und Einer.
456 = 4·100 + 5·10 + 6·1
Dabei sind die Hunderter, Zehner und Einer sogenannte Zehnerpotenzen, also:
1 = 10^0
10 = 10^1
100 = 10^2
1000 = 10^3
10000 = 10^4
usw...
Dabei nennt man 10 die Basis dieses Systems. Man beachte, dass das Zeichen ^ hier das Hoch-Zeichen darstellen soll.
Das Binärsystem
Wenn man nun nur mit zwei Ziffern rechnen will, so setzt man einfach die Basis auf 2 und erhält folgende Zweierpotenzen:
1 = 2^0 = 1
10 = 2^1 = 2
100 = 2^2 = 4
1000 = 2^3 = 8
10000 = 2^4 = 16
100000 = 2^5 = 32
1000000 = 2^6 = 64
10000000 = 2^7 = 128
1 00000000 = 2^8 = 256
10 00000000 = 2^9 = 512
100 00000000 = 2^10 = 1 024
1000 00000000 = 2^11 = 2 048
10000 00000000 = 2^12 = 4 096
100000 00000000 = 2^13 = 8 192
1000000 00000000 = 2^14 = 16 384
10000000 00000000 = 2^15 = 32 768
1 00000000 00000000 = 2^16 = 65 536
10 00000000 00000000 = 2^17 = 131 072
100 00000000 00000000 = 2^18 = 262 144
1000 00000000 00000000 = 2^29 = 524 288
10000 00000000 00000000 = 2^20 = 1 048 576
100000 00000000 00000000 = 2^21 = 2 097 152
1000000 00000000 00000000 = 2^22 = 4 194 304
10000000 00000000 00000000 = 2^23 = 8 388 608
1 00000000 00000000 00000000 = 2^24 = 16 777 216
10 00000000 00000000 00000000 = 2^25 = 33 554 432
100 00000000 00000000 00000000 = 2^26 = 67 108 864
1000 00000000 00000000 00000000 = 2^27 = 134 217 728
10000 00000000 00000000 00000000 = 2^28 = 268 435 456
100000 00000000 00000000 00000000 = 2^39 = 536 870 912
1000000 00000000 00000000 00000000 = 2^30 = 1 073 741 824
10000000 00000000 00000000 00000000 = 2^31 = 2 147 483 648
1 00000000 00000000 00000000 00000000 = 2^32 = 4 294 967 296
...
Dabei kennen Informatiker oftmals bis 2^10 die Zahlen auswendig. Wichtige Zahlen (fettdruck) sind zusätzlich:
256: Dies sind die Anzahl Werte, die mit einem Byte dargestellt werden können. Dieser Wert sollte jedem Informatiker so geläufig sein, wie 1+1=10.
1024: Diese Zahl wird oft für Grössenangaben benutzt. Da sie sehr nahe bei 1000 liegt, wird sie für das Kilo benutzt. Ein Kilobyte sind also 1024 Bytes. Anmerkung: Korrekterweise nennt man diese Grössenangabe nicht Kilo-Byte, sondern Kibi-Byte (Kilobinary), um die Unterscheidung mit 1000 und 1024 zu machen, allerdings ist diese Bezeichnung sozusagen ausgestorben.
65536: Dies sind die Anzahl Werte, die mit zwei Bytes (heute wird diese Grösse short genannt, früher nannte man sie auch word) gebildet werden können.
1048576: Diese Zahl entspricht rund einer Million und ist gleich viel wie 1024 Kilos oder Kilo Kilos (1024 * 1024). Diese Angabe nennt man das Mega (Korrekterweise keisst diese Grösse Mebi: Megabinary)
1073741824: Diese Zahl ist das Giga, also rund 1 Milliarde. Korrekterweise heisst diese Grössenangabe Gibi: Gigabinary
4294967296: Dies sind die Anzahl Werte, die mit 4 Bytes gebildet werden können. Vier Bytes werden heutzutags fast überall für Integer und Pointer gebraucht. Früher nannte man diese Grössenangabe auch DoubleWord. Dies bedeutet, dass mit einem Integer also rund 4 Milliarden verschiedene Werte gebildet werden können. Für einen Pointer bedeutet dies, dass er 4 GB Speicherplatz adressieren kann.
Zurück zu den Binärzahlen: Wenn man nun beispielsweise die Zahl 422 im Binärformat darstellen will, wird folgendes gerechnet:
422 dividiert durch 256 = 1 Rest 166 166 dividiert durch 128 = 1 Rest 38 38 dividiert durch 64 = 0 Rest 38 38 dividiert durch 32 = 1 Rest 6 6 dividiert durch 16 = 0 Rest 6 6 dividiert durch 8 = 0 Rest 6 6 dividiert durch 4 = 1 Rest 2 2 dividiert durch 2 = 1 Rest 0 0 dividiert durch 1 = 0 Rest 0 Somit: 422 = 0b110100110
Das 0b zu Beginn der Binärzahl unterscheidet eine Binärzahl von einer Dezimalzahl. Diese Schreibweise ist derjenigen der Hexadezimalschreibweise 0x nachempfunden und wird beispielsweise beim GNU-Assembler benutzt. Beim 80x86-Assembler ist auch die Schreibweise 110100110b verbreitet. Optional kann dort eine Dezimalzahl mit einem d am Schluss angegeben werden. Grundsätzlich nimmt jedoch jeder Computer bei Zahlen an, dass sie im Dezimalsystem geschrieben stehen, solange sie nicht als anders gekennzeichnet werden. Die Zahl 110100110 wäre dann also hundertzehn Millionen einhundert Tausend und einhundertzehn
. In der obersten Tabelle wurde dieses An- bzw. Nachhängsel extra weggelassen, um die Lesbarkeit zu erhöhen.
Das Hexadezimalsystem
Das Hexadezimalsystem hat die Basis 16, was dazu führt, dass für die Werte 10 bis 15 neue Ziffern
hermüssen. Anstatt neue Zeichen zu kreieren, nimmt man einfach die Buchstaben a bis f:
0 = 0 8 = 8 1 = 1 9 = 9 2 = 2 a = 10 3 = 3 b = 11 4 = 4 c = 12 5 = 5 d = 13 6 = 6 e = 14 7 = 7 f = 15
Ob dabei die Zeichen gross- oder kleingeschrieben sind, spielt normalerweise keine Rolle. Um eine Hexadezimalzahl zu kennzeichnen kann man beim 80x86-Assembler ein h am Ende anfügen, oder aber, wie es heutzutags üblich und fast überall lesbar ist, ein 0x voranhängen (Das x steht für Hexadezimal).
4f36ea17h = 0x4f36ea17
Die Werte, die Hexadezimalzahlen annehmen können, sind die folgenden (man beachte, dass die letzte ausgeführte Zeile zugleich der Grösse eines Integers entspricht):
0x000000001 = 16^0 = 2^0 = 1 0x000000010 = 16^1 = 2^4 = 16 0x000000100 = 16^2 = 2^8 = 256 0x000001000 = 16^3 = 2^12 = 4 096 0x000010000 = 16^4 = 2^16 = 65 536 0x000100000 = 16^5 = 2^20 = 1 048 576 0x001000000 = 16^6 = 2^24 = 16 777 216 0x010000000 = 16^7 = 2^28 = 268 435 456 0x100000000 = 16^8 = 2^32 = 4 294 967 296 ...
Wie man sieht, sind Hexadezimalzahlen eng verwandt mit den Binärzahlen und so ist auch die Umrechnung vom einen in das andere keine grosse Sache:
0 = 0x0 = 0b0000 8 = 0x8 = 0b1000 1 = 0x1 = 0b0001 9 = 0x9 = 0b1001 2 = 0x2 = 0b0010 10 = 0xa = 0b1010 3 = 0x3 = 0b0011 11 = 0xb = 0b1011 4 = 0x4 = 0b0100 12 = 0xc = 0b1100 5 = 0x5 = 0b0101 13 = 0xd = 0b1101 6 = 0x6 = 0b0110 14 = 0xe = 0b1110 7 = 0x7 = 0b0111 15 = 0xf = 0b1111
Hier ein Beispiel, wie man die Zahl 0x4f36ea17 ins Dezimalformat umwandelt:
0x 4 f 3 6 e a 1 7
4 * 268435456 = 1073741824
15 * 16777216 = 251658240
3 * 1048576 = 3145728
6 * 65536 = 393216
14 * 4096 = 57344
10 * 256 = 2560
1 * 16 = 16
7 * 1 = 7
----------
Summe: 1328998935
Wie man sieht, ist die Umrechnung, obschon eher trivial, trotzdem sehr umständlich und mühsam. Aus diesem Grund werden beim Rechnen im Computer die Zahlen normalerweise binär gespeichert, damit er diese Umrechnung nicht jedesmal durchführen muss. Wenn er sie jedoch auf dem Bildschirm als Dezimalzahl darstellen soll, so kann er diese Umrechnung nicht umgehen (Es sei denn, er beherrscht die BCD-Codierung).
Das Oktalsystem
Zum Schluss noch kurz zum Oktalsystem: Dieses hat die Basis 8 mit folgenden Werten:
1 = 8^0 8 = 8^1 64 = 8^2 512 = 8^3 4096 = 8^4 32768 = 8^5 262144 = 8^6 2097152 = 8^7 16777216 = 8^8 134217728 = 8^9 1073741824 = 8^10 ...
Oktalzahlen werden mit einem 0o am Anfang bzw. einem o am Ende geschrieben. Dieses System wird jedoch heutzutags fast nicht mehr verwendet. Die bekannteste noch gebräuchliche Verwendung ist das Vergeben der Sicherheitsflags in einem Unixsystem, wobei dort die Werte folgendermassen verteilt sind:
1 = x = Executable 2 = w = Write 4 = r = Read
So ergibt der bekannte Befehl chmod 755 Dateiname die ebenso bekannten Flags -rwxr-xr-x
, welche bedeuten, dass nur der Eigentümer die Datei schreiben, jedoch jede Gruppe und jede anderweitige Person diese Datei anschauen und gegebenfalls ausführen kann.