Diese Seite ist unverschlüsselt! Um sicherzustellen, das Ihr Passwort nicht ausgelesen werden kann, sollten Sie auf die verschlüsselte Seite wechseln!

    Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » C / C++ (ANSI-Standard) » Zahlendarstellungen
Forum | Hilfe | Team | Links | Impressum | > Suche < | Mitglieder | Registrieren | Einloggen
  Quicklinks: MSDN-Online || STL || clib Reference Grundlagen || Literatur || E-Books || Zubehör || > F.A.Q. < || Downloads   

Autor Thread - Seiten: > 1 <
000
29.12.2007, 00:33 Uhr
Hans
Library Walker
(Operator)


Hi,

angestossen durch die Entwicklung, die dieser Thread genommen hat, hab ich einen Aufsatz über Zahlensysteme verfasst, zumal in den FAQs auch nichts Grundlegendes darüber zu finden ist. Der Aufsatz ist nicht vollständig, aber das was fehlt, ist am Ende aufgelistet, und folgt später noch. Ich stelle ihn hiermit (bzw. mit dem nächsten Beitrag) zur Diskussion und wenn keiner mehr was daran auszusetzen hat, kann Flosoft oder sonst einer der Operatoren den Text in die FAQs verschieben.

Hans


Bearbeitung:
@Flosoft: Liegt die maximale Textlänge eigentlich immer noch bei 10K ?
Ich hab nämlich gerade eine "Text zu lang"-Fehlermeldung bekommen, weil der Aufsatz ungefähr 17K lang ist.

--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.
Dieser Post wurde am 29.12.2007 um 00:36 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
29.12.2007, 00:38 Uhr
Hans
Library Walker
(Operator)


Zahlendarstellungen

In der EDV ist es üblich, das man nicht nur mit den bekannten dezimalen Zahlen arbeitet, sondern auch mit sogenannten Binär- und Hexadezimalzahlen. Was es damit genau auf sich hat, und wie man von einer Darstellung zu einer anderen kommt, darum soll es im folgenden gehen.

Wenn wir im Alltag eine Zahl, wie zum Beispiel 4321 sehen, dann wissen wir, das es sich dabei um die Zahl Viertausend-dreihundert-einundzwanzig handelt. Ein Computer zeigt sie uns meisst auch so an, wenn wir ihn für uns rechnen lassen, oder wenn wir Texte oder Tabellen erstellen. Nun ist es heutzutage auch Allgemeinwissen, das im Computer alles aus Nullen und Einsen zusammengestellt wird. Aber wie das genau geht, ist schon wieder Fachwissen, das nicht mehr jeder hat. Denn wenn man mal unter der Oberfläche von Textverarbeitung oder Tabellenkalkulation nachsieht, dann findet man die 4321 als 0001 0000 1110 0001 dargestellt. Oder auch als 10e1. Das bedeutet beides 4321, nur jedesmal anders ausgedrückt.
Diese Variante:
0001 0000 1110 0001 ist die binäre Darstellung, eben die Nullen und Einsen. Und diese Variante:
10e1 ist die hexadezimale Darstellung, mit der es Softwareentwickler öfter mal zu tun haben. Doch wie kommt man dazu? Fangen wir mit dem bekannten an.


Dezimales Zahlensystem

Unser dezimales Zahlensystem ist ein System, in dem jede Stelle einer Zahl eine bestimmte Wertigkeit zugeordnet wird. (Sowas nennt man auch Stellenwertsystem.) Das bedeutet nichts anderes als das z.B. eine vierstellige Zahl aus einer Tausender, einer Hunderter, einer Zehner und einer Einerstelle besteht. Also:

Code:
1234
^^^^
||||
|||+- Einerstelle
||+-- Zehnerstelle
|+--- Hunderterstelle
+---- Tausenderstelle


Die Mathematik kennt nun die sogenannte Potenzschreibweise, mit deren Hilfe sich so ein Stellenwertsystem formal beschreiben lässt. Wenn man diese Potenzschreibweise auf das obige Beispiel anwendet, d.h. die Zahl 1234 mit Hilfe von Potenzen ausdrückt, kommt das hier dabei heraus:

1234 = 1*10^3 + 2*10^2 + 3*10^1 + 4*10^0

Dabei ist:

Code:
1*10^3 die Tausenderstelle = 1 * 1000 = 1000
2*10^2 die Hunderterstelle = 2 *  100 =  200
3*10^1 die Zehnerstelle    = 3 *   10 =   30
4*10^0 die Einerstelle     = 4 *    1 =    4


Wenn man die Zahlen in der letzten Spalte zusammenrechnet kommt 1234 heraus.

Anmerkungen zu Potenzen und zur Schreibweise
Da die in der Mathematik übliche Schreibweise hier schlecht umsetzbar ist, wird das ^-Zeichen als Potenzzeichen benutzt, wie es auch manchen Programmiersprachen der Fall ist. BASIC wäre ein Beispiel dafür. Aber was bedeutet eigentlich Potenz?
Wenn irgendwo, wie oben z.B. 10^3 oder 10³ (gelesen zehn hoch drei) steht, dann bedeutet dies das gleiche wie 10 * 10 * 10. Also bedeutet

10^3 = 10 * 10 * 10 = 1000

Die Hochzahl, (die im Fachchinesisch auch Exponent heisst) gibt an, wie oft die Zahl, an der sie dran steht, (im Fachchinesisch als Basis bezeichnet) mit sich selbst malzunehmen (zu multiplizieren) ist. Es ist ausserdem festgelegt, das irgendwas hoch Null also X^0 immer Eins ergibt. Deshalb kommt bei 10^0 auch 1 heraus.
Ein weiteres Beispiel: Die Zahl 5847 stellt sich in der Potenzschreibweise so dar:

Code:
5847 = 5*10^3 + 8*10^2 + 4*10^1 + 7*10^0
     = 5*1000 + 8*100  + 4*10   + 7*1
     = 5000   + 800    + 40     + 7
     = 5847



Binäres Zahlensystem

Das binäre Zahlensystem kennt nur zwei Ziffern, nämlich die Null und die Eins. Und im Gegensatz zum dezimalen Zahlensystem hat man es hier mit sogenannten Zweierpotenzen zu tun, während es im dezimalen System Zehnerpotenzen sind. Man hat also keine Zehner, Hunderter oder Tausenderstellen, sondern 2er, 4er, 8er usw. Die einzelnen Stellen sind wie folgt zugeordnet:

Code:
xxxx
^^^^
||||
|||+- Einerstelle,  entspricht 2^0 = 1
||+-- Zweierstelle, entspricht 2^1 = 2
|+--- Viererstelle, entspricht 2^2 = 4
+---- Achterstelle, entspricht 2^3 = 8


Nehmen wir nun als Beispiel die binäre Zahl 1001. Wenn man diese Zahl mit Hilfe von Potenzen ausdrückt, erhält man:

1001 = 1*2^3 + 0*2^2 + 0*2^1 + 1*2^0

Dabei ist:

Code:
1*2^3 die Achterstelle = 1 * 8 = 8
0*2^2 die Viererstelle = 0 * 4 = 0
0*2^1 die Zweierstelle = 0 * 2 = 0
1*2^0 die Einerstelle  = 1 * 1 = 1


Also:

Code:
1001 = 1*2^3 + 0*2^2 + 0*2^1 + 1*2^0
     = 1*8   + 0*4   + 0*2   + 1*1
     = 8     + 0     + 0     + 1
     = 9


Und damit haben wir die binäre Zahl auch gleich in eine dezimale Zahl umgerechnet.
Wenn man öfter mit binären Zahlen zu tun hat, kann folgende tabellarische Darstellung hilfreich sein, um binäre Zahlen schnell in dezimale Zahlen umzurechnen:

Code:
2^7 | 2^6 | 2^5 | 2^4 | 2^3 | 2^2 | 2^1 | 2^0
128 |  64 |  32 |  16 |   8 |   4 |   2 |   1
----+-----+-----+-----+-----+-----+-----+-----
b7 |  b6 |  b5 |  b4 |  b3 |  b2 |  b1 |  b0



b7, b6, b5, b4, b3, b2, b1 und b0 sind dabei die Ziffern der binären Zahl, also entweder 0 oder 1, die man entsprechend in die Tabelle einträgt. Anhand der Wertigkeiten, die in der oberen bzw. mittleren Zeile stehen, kann man dann sehr schnell die Zahl bestimmen, indem man alle diejenigen Werte aus der mittleren Zeile zusammenzählt, die eine Eins in der unteren Zeile haben. Beispiel: Wir tragen die binäre Zahl 1100 1011 in die Tabelle ein:

Code:
2^7 | 2^6 | 2^5 | 2^4 | 2^3 | 2^2 | 2^1 | 2^0
128 |  64 |  32 |  16 |   8 |   4 |   2 |   1
----+-----+-----+-----+-----+-----+-----+-----
1  |  1  |  0  |  0  |  1  |  0  |  1  |  1



D.h.

Code:
b7 = 1  |  b3 = 1
b6 = 1  |  b2 = 0
b5 = 0  |  b1 = 1
b4 = 0  |  b0 = 1


Die Zahlen aus den Spalten, in dessen unterster Zeile ein Eins steht, zählen wir zusammen. Hier also 128 + 64 + 8 + 2 + 1, macht zusammen 203.
In Potenzschreibweise sieht die Zahl übrigens so aus:

1100 1011 = 1*2^7 + 1*2^6 + 0*2^5 + 0*2^4 + 1*2^3 + 0*2^2 + 1*2^1 + 1*2^0

Insgesammt lassen sich mit acht binären Stellen dezimale Zahlen zwischen Null und 255 darstellen, denn 128 + 64 + 32 + 16 + 8 + 4 + 2 + 1 = 255.



Hexadezimales Zahlensystem

Da das binäre Zahlensystem auf Dauer etwas umständlich , bzw. schwer zu lesen ist, und Informatiker hin und wieder zu kurzschreibweisen neigen, haben sie das hexadezimale Zahlensystem erdacht. Das basiert auf der Zahl 16, d.h. mit einer Stelle können 16 verschiedene Werte angezeigt werden. Da unsere Schrift aber nur 10 Ziffernsymbole kennt, nämlich 0, 1, 2, 3, 4, 5, 6, 7, 8 und 9 haben die Erfinder des hexadezimalen Systems kurzerhand noch die ersten sechs Buchstaben des Alphabets, also a, b, c, d, e, f dazu genommen, um 16 verschiedene Werte mit einem Zeichen darstellen zu können. Die Zuordnung ist wie folgt:

Code:
Dez.  Hex. | Dez.  Hex.
00    00   |  08    08  
01    01   |  09    09  
02    02   |  10    0a  
03    03   |  11    0b  
04    04   |  12    0c  
05    05   |  13    0d  
06    06   |  14    0e  
07    07   |  15    0f  



Dabei ist es egal, ob man Gross- oder Kleinbuchstaben verwendet. Die Zahl A hat genau die selbe Bedeutung wie a, nämlich dezimal Zehn.
Dieses System hat dazu noch die besondere Eigenschaft, jeweils vier binäre Ziffern zu einer hexadezimalen Ziffer zusammen zu fassen. Das sieht so aus:

Code:
Dez.  Bin.   Hex.
00    0000   0
01    0001   1
02    0010   2
03    0011   3

04    0100   4
05    0101   5
06    0110   6
07    0111   7

08    1000   8
09    1001   9
10    1010   a
11    1011   b

12    1100   c
13    1101   d
14    1110   e
15    1111   f


Und auch dieses System lässt sich natürlich in Potenzschreibweise darstellen. In diesem Fall rechnen wir mit 16er-Potenzen. Eine hexadezimale Zahl A3F9 stellt sich in Potenzform so dar:

A3f9 = 10*16^3 + 3*16^2 + 15*16^1 + 9*16^0

Die niedrigste Stelle hat dabei wieder die Wertigkeit Eins, die nächst höhere Stelle die Wertigkeit 16 und die Stelle darüber die Wertigkeit 16*16 = 256. Man kann also sagen, das man eine Einser-, eine 16er, eine 256er-Stelle, usw. hat. Das ist allerdings in der Praxis eher ungewöhnlich, soweit ich weis. Ich verwende es hier, um das Erklärungsmuster beibehalten zu können. Dann erhält man das folgende Bild:

Code:
xxxx
^^^^
||||
|||+- Einerstelle (1er),       entspricht 16^0 =  1
||+-- Sechzehnerstelle (16er), entspricht 16^1 = 16
|+--- Zweihundert-sechundfünfzigerstelle ( 256er), entspricht 16^2 =  256
+---- Viertausend-sechundneunzigerstelle (4096er), entspricht 16^3 = 4096

Damit erklärt sich auch, warum man bestenfalls noch von Einer oder Sechzehnerstellen spricht, alles darüber ist schon wieder zu umständlich.
Aber wir haben ja noch die Potenzschreibweise. Die ist kürzer und damit kann man besser rechnen. Also rechnen wir die hexadezimale Zahl A3F9 mal ins dezimale System um:

Code:
A3F9 = 10*16^3 + 3*16^2 + 15*16^1 + 9*16^0
     = 10*4096 + 3*256  + 15*16   + 9*1
     = 40960   + 768    + 240     + 9
     = 41977 dezimal


Wie oben beschrieben, eignet sich die hexadezimale Darstellung auch sehr gut als eine Art Kurzfassung des Binären Systems gemäss der oben schon angegebenen Tabelle.
Damit ergibt sich die binäre Form der hexadezimalen Zahl A3F9 zu:

Code:

hex. |   a  |   3  |   f  |   9  
-----+------+------+------+------
Bin. | 1010 | 0011 | 1111 | 1001

oder 1010001111111001.

Ein weiteres Beispiel. Nehmen wir an, die ganz zu Anfang verwendete Zahl 4321 ist keine dezimale sondern eine hexadezimale Zahl. Was wäre das dezimal? Dazu müssen wir wieder die Potenzen bemühen, also:

Code:
4321 = 4*16^3 + 3*16^2 + 2*16^1 + 1*16^0
     = 4*4096 + 3*256  + 2*16   + 1*1
     = 16384  + 768    + 32     + 1
     = 17185 dezimal

--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.
Dieser Post wurde am 29.12.2007 um 00:40 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
29.12.2007, 00:43 Uhr
Hans
Library Walker
(Operator)


Die bisher verwendete Potenzschreibweise lässt sich auch noch allgemein darstellen, was ich hier noch machen will. (In den meissten Büchern ist es ja umgekehrt. Da wird die Potenzschreibweise zuerst erklärt. Oder sie wird als bekannt voraus gesetzt, d.h. gar nicht erklärt.) Stellen wir die Potenzschreibweisen der einzelnen Zahlensysteme mal untereinander:

Code:
Dezimal      1234 =  1*10^3 + 2*10^2 +  3*10^1 + 4*10^0
Binär        1001 =  1* 2^3 + 0* 2^2 +  0* 2^1 + 1* 2^0
HexaDezimal  A3f9 = 10*16^3 + 3*16^2 + 15*16^1 + 9*16^0


Wenn wir die Zahlen vor dem ^-Zeichen vergleichen, stellen wir fest, das sie in jeder Zeile gleich sind. Bei den dezimalen Zahlen ist es die Zehn, bei den binären Zahlen die Zwei und bei den hexadezimalen Zahlen die 16. Diese Zahl nennt man die Basis des jeweiligen Zahlensystems.
Wenn wir die Zahlen hinter dem ^-Zeichen vergleichen, stellen wir fest, das sie in jeder Spalte gleich sind. Diese nennt man Exponent, sie gibt die jeweilige Stelle einer Ziffer an.
Dann wäre da noch der Faktor; das ist die Zahl vor dem * (Stern), der als Multiplikationszeichen dient. Der Faktor gibt den Wert der jeweiligen Stelle an.
Damit ergibt sich die Ziffer eines Zahlensystem formal also zu:

Ziffer = Faktor * Basis ^ Exponent

Die Einerstelle hat dabei den Exponent 0 (Null), denn es ist definiert, das eine beliebige Zahl x mit dem Exponent Null immer Eins ist. Also:

x^0 = 1

Die zweite Stelle lässt sich nicht mehr Eindeutig benennen, weil man die Basis des Zahlensystem wissen muss. Beim dezimalen Zahlensystem nennt man sie Zehnerstelle, beim binären Zahlensystem Zweierstelle und bei den Hexadezimalen Zahlen kann man von einer 16er-Stelle reden. Bei der dritten Stelle wird es kompliziert, wie bei den hexadezimalen Zahlen gezeigt. Deshalb ist zu Empfehlen, immer von der ersten, zweiten oder soundsovielten Stelle zu reden. Damit nennt man sie bei ihrer Nummer, und erspart sich umständliche Namen.

Mit dieser Schreibweise: "Ziffer = Faktor * Basis ^ Exponent" kann man eine beliebige Zahl formal mathematisch beschreiben, ohne das sie einen bestimmten Wert hat. Dazu nimmt man eine Zahl, die wir mal A nennen. A möge fünf Stellen haben. Die Ziffern dieser Stellen bezeichnen wir mit a0, a1, a2, a3 und a4, wobei a0 die erste, oder niederwertigste Stelle ist, und a4 die letzte, oder höchstwertige Stelle. Diese Zahl A ist aus einem Zahlensystem zur Basis P. Damit ergibt sich die Zahl A in Potenzschreibweise zu:

A = a4*P^4 + a3*P^3 + a2*P^2 + a1*P^1 + a0*P^0

Das kann man natürlich auch auf (theoretisch) unendlich viele Stellen erweitern. Dazu bezeichnet man die höchste Stelle mit n, d.h. es die n-te Stelle ist die höchst mögliche. Eine Zahl B mit n Stellen sieht dann in der Potenzschreibweise so aus:

B = bn*P^n + ... + b4*P^4 + b3*P^3 + b2*P^2 + b1*P^1 + b0*P^0

Mit dieser allgemeinen Darstellung kann man sich beliebige andere andere Zahlensysteme basteln. Es gibt da zum Beispiel noch das oktale Zahlensystem zur Basis acht. Das wurde früher verwendet, und geistert noch durch die Literatur. Der Vollständigkeit halber lass ich es hier auch noch herum geistern
Die Basis 8 bedeutet, das es nur 8 Ziffern gibt, nämlich 0, 1, 2, 3, 4, 5, 6 und 7. Wenn man also oktal zählt, kommt nach der 7 die 10, und nach der 17 die 20. Ein besseres Beispiel: die oktale Zahl 127776. In Potenzschreibweise ergibt sie:

127776 = 1*8^5 + 2*8^4 + 7*8^3 + 7*8^2 + 7*8^1 + 6*8^0

Das rechnen wir mal eben ins dezimale System um:

Code:
127776 = 1*8^5   + 2*8^4  + 7*8^3 + 7*8^2 + 7*8^1 + 6*8^0
       = 1*32768 + 2*4096 + 7*512 + 7*64  + 7*8   + 6*1
       = 32768   + 8192   + 3584  + 448   + 56    + 6
       = 45054


(Wer diese Zahl jetzt ins hexadezimale System umrechnet, möge sich bitte nicht beleidigt fühlen, denn die Zahl ist mit dem Namen einer bekannten Tierart identisch.)
Der hauptsächliche Verwendungszweck des oktalen Zahlensystems war der, das man binäre Ziffern damit sehr gut zu Dreiergruppen zusammenfassen kann. Nehmen wir die obige Zahl 127776:

Code:
Oktal:  1   2   7   7   7   6
Binär: 001 010 111 111 111 110


Wenn man mit oktalen Zahlen die Speicheradressen eines Rechners nummeriert, hat man 18 Bit zur Verfügung. Das bedeutet, das man von Null bis 2^18 = 262.144 kommt; das wären 256 Kilobyte Speicher, die sich mit einer sechsstelligen Oktalzahl beschreiben lassen. Nun sind 256 KB heutzutage aber nicht mehr sonderlich viel - zumindest bei PCs. Und selbst Mobiltelefone haben eine vielfach grössere Speicherkapazität. Also nehmen wir mal an, wir wollen einen Speicher von 512 MB oktal nummerieren. Ein MB sind 2^20 Byte, 512 MB demnach 512*2^20 = 536.870.912 Byte (dezimal dargestellt). Die oktale Form sieht zwar sehr glatt aus, nämlich 4.000.000.000, ist mit 10 Stellen aber etwas lang. Die hexadezimale Darstellung: 20.000.000 ist mit 8 Stellen zwar nicht viel kürzer, hat aber einen anderen Vorteil. Dieser offenbart sich, wenn man die binäre Darstellung näher untersucht.
Es hat sich eingebürgert, das ein Byte aus 8 Bit besteht, was wiederum einer achtstelligen Binärzahl entspricht. Wenn man jetzt zu Dreiergruppen zusammengefasste Binärzahlen genauer untersucht, stellt man fest, das in der dritten Gruppe von rechts gezählt eine Bytegrenze ist. Die höchste Stelle dieser Bitgruppe passt nicht mehr in ein Byte hinein, was bedeutet, das man dafür ein weiteres benötigt. An einer Wortgrenze (1 Wort = 16 Bit) hat man ein ähnliches Problem. Da steht das höchstwertige Bit immer für sich alleine. Wenn man zwei (Daten-)Wörter hintereinander schreibt, und die Bits in Dreiergruppen aufteilt, hat man die Wortgrenze wieder mitten in einer solchen Dreiergruppe. Die folgende Darstellung verdeutlicht das:

Code:
"Oktale Gruppierung"        
  0  1   1   Y    5   4      
            0 11 101 100      
        001 1 11 101 100      
  0 001 001 1 11 101 100      
^           ^                  
|           |                  
|           +- Bytegrenze      
|                              
+- Wortgrenze  



Wie man hier sehen kann, ziehen die Byte- und Wortgrenzen die Dreiergruppen der Ziffern auseinander. Wenn man aber viel mit Bitmustern d.h. mit binären Zahlen hantiert, dann unterlaufen einem an diesen Stellen beim Umrechnen eher Fehler, weil man die Byte- bzw. Wortgrenzen leicht übersieht. Dieses Problem, man nicht, wenn man die binären Ziffern zu Vierergruppen zusammen fasst. Denn dabei liegen die Byte- bzw. Wortgrenzen zwischen den Vierergruppen der binären Ziffern. Und vier Bits ergeben eine hexadezimale Ziffer, womit wir beim Vorteil dieses Systems wären...

Code:
"Hexadezimale Gruppierung"
      1    3    e    c
              1110 1100
         0011 1110 1100
    0001 0011 1110 1100
   ^         ^  
   |         |
   |         +- Bytegrenze
   |
   +- Wortgrenze    



Ein weiteres Problem, das sich bei den oktalen Zahlen durch die Bytegrenze ergibt, sieht man oben an der Stelle Y. Im Fall der 8-Bit-Zahl steht dort eine 3, im Fall der 16-Bit-Zahlen steht dort eine 7. Eine "wunderschöne" Fehlerquelle, wenn man mit Bytes und Worten operiert!

Soweit erst mal das. Was noch fehlt, ist:
- Wie man von dezimalen Zahlen zur binären, bzw. hexadezimalen Darstellung kommt
- Wie Nachkommastellen (Brüche) dargestellt werden.
- wie Fliesspunktzahlen dargestellt werden; IEEE-Format
- wie sich das alles im Speicher präsentiert

Aber dazu komme ich im nächsten Akt...
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.
Dieser Post wurde am 28.07.2015 um 13:46 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
29.12.2007, 01:14 Uhr
Guybrush Threepwood
Gefürchteter Pirat
(Operator)


Ganz schön viel

Ich verschiebs mal in die FAQ

EDIT: Auf Wunsch nochmal zurück
Dieser Post wurde am 29.12.2007 um 14:12 Uhr von Guybrush Threepwood editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
03.01.2008, 11:10 Uhr
wolf360



 o_O das is wirklich ganz schön viel!!

aber ich muss sagn, endlich hat es "klick" gemacht!

habs endlich kappiert!!

danke für die gute und ausführliche Erklärung!!

gruß wolf360
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
24.11.2010, 10:38 Uhr
Hans
Library Walker
(Operator)


Zahlendarstellungen Teil 2

Bisher ging es darum, wie man von der binären, hexadezimalen oder oktalen Darstellung auf die dezimale Darstellung kommt. Dabei blieb die Frage ausgeklammert, wie man der von dezimalen Form zur binären, bzw. hexadezimalen Darstellung kommt. Diese soll nun beantwortet werden.


Dezimal nach Binär

Fangen wir mit dem einfachsten an, nämlich eine dezimale Zahl in eine Binäre umzurechnen. Zum Beispiel die dezimale Zahl 19. Dazu rechnen wir:

Code:
  19 : 2 = 9  Rest 1
   9 : 2 = 4  Rest 1
   4 : 2 = 2  Rest 0
   2 : 2 = 1  Rest 0
   1 : 2 = 0  Rest 1


Jetzt stellt sich natürlich die Frage, wozu die Reste aufgeführt sind, die bei der Division (also beim teilen) anfallen, und warum ich nicht mit Nachkommastellen weiter gerechnet habe?
Die Antwort ist: Wenn man die Reste von unten nach oben aneinander reiht, also 10011, dann hat man die gesuchte binäre Darstellung der Zahl, in diesem Fall also von 19.
Gegenprobe:
Code:
  1*2^4 + 0*2^3 + 0*2^2 + 1*2^1 + 1*2^0 =
  1* 16 + 0     + 0     + 1* 2  + 1* 1  =
    16  + 0     + 0     +   2   +   1   =

    16 + 2 + 1 = 19              

Die Nachkommastellen, die beim Teilen anfallen brauchen wir nicht. Diese spezielle Form der Division mit ganzen Zahlen nennt man auch "modulo"-Rechnung. Dabei wird ermittelt, welcher Rest übrig bleibt, wenn man eine Zahl A durch eine Zahl B teilt, wobei nur ganzzahlige Ergebnisse zugelassen sind. Dazu kommen wir später noch mal.
Man kann die Gegenprobe auch mit der weiter oben (vorheriger Artikel) aufgeführten Tabelle machen, dass sieht dann so aus:
Code:
  2^7 | 2^6 | 2^5 | 2^4 | 2^3 | 2^2 | 2^1 | 2^0
  128 |  64 |  32 |  16 |   8 |   4 |   2 |   1
  ----+-----+-----+-----+-----+-----+-----+-----
   0  |  0  |  0  |  1  |  0  |  0  |  1  |  1

Wir tragen also die oberste Zahl, bzw. das erste Zwischenergebnis unserer Rechnung ganz rechts in der Tabelle ein, und alle weiteren jeweils links davon in der nächsten Spalte. Danach kann man mit Hilfe dieser Tabelle gleich 16+2+1 rechenen, da man die Wertigkeit der einzelnen Stellen sofort sieht.

Als weiteres Beispiel rechnen wir mal die dezimale Zahl 108 in die binäre Darstellung um:
Code:
  108 : 2 = 54 Rest 0
   54 : 2 = 27 Rest 0
   27 : 2 = 13 Rest 1
   13 : 2 =  6 Rest 1
    6 : 2 =  3 Rest 0
    3 : 2 =  1 Rest 1
    1 : 2 =  0 Rest 1


Die Reste von unten nach oben aneinander gereiht ergeben 1101100. Zur Probe setzen wir das in die Tabelle ein:
Code:
  2^7 | 2^6 | 2^5 | 2^4 | 2^3 | 2^2 | 2^1 | 2^0
  128 |  64 |  32 |  16 |   8 |   4 |   2 |   1
  ----+-----+-----+-----+-----+-----+-----+-----
      |  1  |  1  |  0  |  1  |  1  |  0  |  0

Das besagt nun, das wir 64+32+8+4 rechnen sollen, um wieder auf die gewünschte dezimale Zahl, also 108 zu kommen.


Dezimal nach Hexadezimal

Nun zu den hexadezimalen Zahlen. Die Methode ist wieder die Gleiche, nur das wir diesmal nicht durch 2, sondern durch 16 teilen. Nehmen wir zum Einstieg mal wieder die dezimale Zahl 19; wir rechnen also:
Code:
  19 : 16 = 1 Rest 3
   1 : 16 = 0 Rest 1

Die Reste von unten nach oben aneinander gereiht ergeben 13. Das heist also 1*16+3=19. Oder ausführlich:
Code:
  1*16^1 + 3*16^0
  1*16   + 3*1
    16   + 3      = 19


Als weiteres Beispiel nehmen mal eine grössere Zahl, also etwa 2501. Die Rechnung geht dann so:
Code:
  2501 : 16 = 156 Rest  5
   156 : 16 =   9 Rest 12
     9 : 16 =   0 Rest  9

Die Reste sind also 9, 12 und 5. Die Hexadezimale Zahl ist aber nicht 9125, denn für die Reste, deren dezimaler Wert grösser oder gleich Zehn ist, sind ja Buchstaben einzusetzen, wobei diese Zuordnung gilt:
10 <=> a | 11 <=> b | 12 <=> c
13 <=> d | 14 <=> e | 15 <=> f

Für die 12 ist also ein C einzusetzen. Damit ergibt sich die hexadezimale Zahl zu 9c5. Um darauf hinzuweisen, dass es sich um eine hexadezimale Zahl handelt, hängt man häufig ein h an, schreibt also 9c5h. Eine andere Möglichkeit ist ein voran gestelltes Dollarzeichen, das sieht dann so aus: $9c5. Beides bedeutet das Gleiche. Wer jedoch viel mit Intel-Prozessoren zu tun hat, wird hauptsächlich die erste Variante finden.

Wenn man diese Rechnungen nun mit einem Taschenrechner nachrechnet, der zum einen keine Reste kennt, und zum anderen keine Zahlenumwandlung per Knopfdruck durchführt, stellt sich natürlich die Frage, wie man an die Reste kommt? - Das ist möglich, indem man zum einen auf einem Blatt Papier mitschreibt, zum anderen den Rechner ein paar zusätzliche Rechnungen durchführen lässt. Ich demonstriere das mal anhand des vorherigen Beispiels. Wir rechnen also 2501:16 und erhalten 156,3125. Wir notieren:
Code:
2501 : 16 = 156 Rest

Die 156 brauchen wir gleich wieder, deshalb notieren wir sie. Jetzt interessiert uns aber erst mal der Rest, der Division und nicht die Nachkommastellen. Aber genau die brauchen wir jetzt. Dazu ziehen wir die 156 von der Zahl im Display ab, so das nur die Nachkommastellen übrig bleiben, hier also 0,3125. Diese 0,3125 multiplizieren wir mit 16 und erhalten 5 und damit unseren gesuchten Rest, den wir wieder notieren. Zusammengefasst sieht die Rechnung also so aus:
Code:
//////////////////////////////////////////////////////////////////////////////////////
  1. Schritt              2. Schritt                 3. Schritt          
  2501 : 16 = 156,3125 -> 156,3125 - 156 = 0,3125 -> 0,3125 * 16 = 5 <- gesuchter Rest

Nachdem wir diesen Rest wieder notiert haben können wir die nächste Stelle berechnen, also:
Code:
  156 : 16 =   9,75


Von den 9,75 ziehen wir wieder den ganzzahligen Teil, also 9 ab, und rechnen mit dem gebrochenen Anteil weiter. In diesem Fall: 0,75 * 16 und erhalten 12. Die Ermittelung des Restes erfolgt also mit Hilfe zweier weiterer Rechnungen. Also erstes ermitteln wir den gebrochenen Anteil des Ergebnisses, indem wir den ganzzahligen Teil abziehen. Diesen multiplizieren wir anschliessend mit der Basis des Zahlensystems, in das wir die Zahl umrechnen wollen. Die ganze Berechnung mit allen Zwischenschritten sieht also so aus:
Code:
////////////////////////////////////////////////////////////////////////////////////////
  1. Schritt              2. Schritt                 3. Schritt            
  2501 : 16 = 156,3125 -> 156,3125 - 156 = 0,3125 -> 0,3125 * 16 =  5 <- gesuchter Rest
   156 : 16 =   9,75   ->   9,75   -   9 = 0,75   -> 0,75   * 16 = 12 <- also C
     9 : 16 =   0,5625 ->                         -> 0,5625 * 16 =  9


Als weiteres Beispiel mal die Zahl 64639, ebenfalls mit allen Zwischenschritten:
Code:
////////////////////////////////////////////////////////////////////////////////////////
  1. Schritt                 2. Schritt                   3. Schritt            
  64639 : 16 = 4039,9375  -> 4039,9375 - 4039 = 0,9375 -> 0,9375 * 16 = 15
   4039 : 16 =  252,4375  ->  252,4375 -  252 = 0,4375 -> 0,4375 * 16 =  7
    252 : 16 =   15,75    ->   15,75   -   15 = 0,75   -> 0,75   * 16 = 12
     15 : 16 =    0,9375  ->                           -> 0,9375 * 16 = 15


Um das zu überprüfen stellen wir mal wieder eine Tabelle auf. Diesmal enthält sie aber keine 2er Potenzen, sondern 16er Potenzen. Wir schreiben unsere Reste von oben nach unten, sowie von rechts nach links in die Tabelle, und erhalten:
Code:
  16^3 | 16^2 | 16^1 | 16^0
  4096 |  256 |   16 |   1
  -----+------+------+-------
   15  |  12  |   7  |  15  
    F  |   C  |   7  |   F

Wenn die zweistelligen Ergebnisse noch durch die entsprechenden Buchstaben ausgetauscht werden, erhalten wir die gesuchte Zahl, nämlich FC7F. Zur Probe rechen wir also:
Code:
15*16^3 + 12*16^2 + 7*16^1 + 15*16^0
15*4096 + 12*256  + 7*16   + 15*1    =
61440   + 3072    +  112   + 15      = 64639

Das passt also. Um sich rechenarbeit beim ermitteln der Reste zu sparen, kann es auch nützlich sein, diese ebenfalls wieder in eine Tabelle zu packen, aus der man für den gebrochenen Anteil der Division gleich den zugehörigen Rest ablesen kann. Das würde etwa so aussehen:
Code:
   1:16 = 0,0625 <=> 1
   2:16 = 0,125  <=> 2
   3:16 = 0,1875 <=> 3
   4:16 = 0,25   <=> 4
   5:16 = 0,3125 <=> 5
   6:16 = 0,375  <=> 6
   7:16 = 0,4375 <=> 7
   8:16 = 0,5    <=> 8
   9:16 = 0,5625 <=> 9
  10:16 = 0,625  <=> A
  11:16 = 0,6875 <=> B
  12:16 = 0,75   <=> C
  13:16 = 0,8125 <=> D
  14:16 = 0,875  <=> E
  15:16 = 0,9375 <=> F



Dezimal nach Oktal

Um eine dezimale Zahl in eine Oktale umzurechnen können wir wieder den selben Weg nehmen, wie schon bei den binären und hexadezimalen Zahlen. Wir teilen einfach wieder durch die Basis, und notieren die Reste. Als einführendes Beispiel wieder mal die 19:
Code:
   1. Schritt           2. Schritt              3. Schritt            
  19 : 8 = 2,375 -> 2,375 - 2 = 0,375 -> 0,375 * 8 = 3  --> 19 : 8 = 2 Rest 3
   2 : 8 = 0,25  ->                      0,25  * 8 = 2  -->  2 : 8 = 0 Rest 2

Aus der dezimalen 19 wird im oktalen also eine 23. Die Zahl 2501 dezimal wird so zu:
Code:
  2501 : 8 = 312 Rest 5  (312,625 -> 0,625 * 8 = 5)
   312 : 8 =  39 Rest 0
    39 : 8 =   4 Rest 7  (  4,875 -> 0,875 * 8 = 7)
     4 : 8 =   0 Rest 4  (  0,5   -> 0,5   * 8 = 4)

Das heisst 4705 ist unsere gesuchte Oktalzahl. Das kann man auch wieder mit einer Tabelle überprüfen, die jetzt 8er-Potenzen enthält:
Code:
  8^3 | 8^2 | 8^1 | 8^0
  512 |  64 |   8 |   1
  ----+-----+-----+-----
   4  |  7  |  0  |  5  



Dann wäre eventuell noch die Frage zu klären, wie man von Hexadezimal nach Oktal kommt, und umgekehrt?
Dazu kann man die Zahlen erst mal ins dezimale System umrechnen, und von dort ins gesuchte, aber das ist der umständliche Weg. Viel einfacher ist es, über die binären Zahlen zu gehen. Denn wie oben schon (im vorherigen Beitrag) erläutert, umfasst eine oktale Ziffer genau 3 binäre Stellen (3 Bits) und eine hexadezimale Ziffer genau 4 binäre Stellen (4 Bits). Und mit ein bisschen Übung (oder einer Umrechnungstabelle) schreibt man sich erst mal die Bitmuster der einen Zahl hin, und gruppiert die Bits anschliessend neu. Dann ordnet man den Bitgruppen die entsprechenden Ziffern zu und hat das Ergebnis.
Nehmen wir zum Beispiel mal die Zahl oktale Zahl 6712. Da jede Ziffer einer Dreiergruppe von Bits entspricht, kann man also (anfangs mit Tabellenhilfe) hinschreiben:
Code:
oktal  6   7   1   2
binär 110 111 001 010    

Die Dreiergruppen der Ziffern lösen wir auf und fassen sie zu Vierergruppen zusammen:
Code:
binär   110 111 001 010    
                        
binär   1101 1100 1010    

ordnen ihnen die Ziffern zu:
Code:
binär   1101 1100 1010    
hex      D    C    A


und haben das Ergebnis.

Weiteres Beispiel: 1273 oktal;
Code:
okt.:  1   2   7   3  
bin.: 001 010 111 011  neu gruppieren

bin.: 0010 1011 1011
hex.:  2    B    B


Umgekehrt geht es genau so:
Code:
hex.:  A    B    1
bin.: 1010 1011 0001  neu gruppieren

bin.: 101 010 110 001
okt.:  5   2   6   1


Soweit der zweite Teil zum Thema Zahlendarstellungen. Damit wären die ganzen Zahlen und die vier in der EDV gebräuchlichen Zahlensysteme abgehakt. Wer will, kann sich nun ein eigenes Zahlensystem, beispielsweise zur Basis 12 basteln, wenn es der Anwendung nützt. Interessant wäre auch ein Zahlensystem zur Basis grösser/gleich 37, das mit lateinischen Buchstaben auskommt...
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.
Dieser Post wurde am 24.11.2010 um 11:32 Uhr von Hans editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ C / C++ (ANSI-Standard) ]  


ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: