Herzlich Willkommen, lieber Gast!
  Sie befinden sich hier:

  Forum » Borland C++ Builder » Von Dezimal ins Binärsystem

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
03.04.2003, 15:16 Uhr
~Anfaenger
Gast


Hi Leute, soll ein Programm unter C++ Builder schreiben, das Dezimalzahlen in Binärsystem umwandelt.
Es soll die Binärzahl ausgegeben werden.
Hat jemand ne idee, wie ich es anstelle?
Freue mich über jeden lösungsvorschlag und danke im Vorraus.
Gruß
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
001
05.04.2003, 14:35 Uhr
Chillmaster



Sowas macht man mit dem Modulo - Operator.

Versuch mal mit Papier und Bleifstift eine Dezimalzahl ins Binärsystem umzuwandeln.
Du wirst die Dezimalzahl nehmen und durch die Basis (beim Binärsystem 2) teilen. Dann notierst du dir das Ergebnis in folgender Form.
Zahl, Rest
Also bei der Zahl 15 würde das so aussehen.
15 geteilt durch 2 ...
das ist 7 Rest 1
Der Rest (beim Binärsystem kann er nur 0 oder 1 sein) ist deine erste Zahl, die schreibst du ganz rechts hin. Jetzt nimms du das ganzzahlige Ergebnis, das rauskam und machst das gleiche damit. Bis die ganze Zahl 0 ist. Dann hörst du auf und hast deine Binärzahl dastehen. Zum Beispiel von oben:

Bisheriges Ergebnis: . . . . . . . 1

so jetzt nehmen wir 7, teilen durch 2: 3 Rest 1

Bisheriges Ergebnis: . . . . . . 1 1

jetzt nehmen wir die 3 und teilen durch 2: 1 Rest 1.

Bisheriges Ergebnis: . . . . . 1 1 1

jetzt nehmen wir die 1 und teilen wieder durch 2: 0 Rest 1.

ENDERGEBNIS, Da ganze Zahl 0: . . . . 1 1 1 1

Die Punkte kann man nun weglassen: 1 1 1 1
Das ist 15 im Binärsystem.

Nachfolgend hab ich ein schnell zusammengebasteltes Programm, das ungefähr genaus so arbeitet:


C++:
// Programm zum Umwandeln von Dezimalzahlen in Binärzahlen
#include <iostream.h>
#include <conio.h>

int main();

int main()
{
  const unsigned short AnzahlStellen = 16;

  unsigned short aBin[AnzahlStellen];  // Da kommt das Ergebnis rein.
  unsigned short dez;
  short i;
  for (i = 0; i < AnzahlStellen; i++)
    aBin[i] = 0;

  cout << "Geben Sie eine Dezimalzahl ein: ";
  cin >> dez;

// Wie oben beschrieben: Die for Schleife kontroliert, ob Zahl > 0, und teilt sie
// jedesmal durch 2 (Da es ein Integer ist, ist das Ergebnis eine Ganzzahl).
// Dem Array aBin wird der Rest von der Division zugewiesen.
  for (unsigned short Zahl = dez, i = 0;  Zahl > 0;  Zahl /= 2, i++)
    aBin[i] = Zahl % 2;    

// Ausgabe erfolgt rückwärts. Da wir es von Hand ja auch von Rechts nach
// Links schreiben.
  cout << "Dezimalzahl: " << dez << "\t\tBinaer: ";

  bool schreiben = false;
  for ( i = AnzahlStellen - 1;  i >= 0;  i--)
  {
    if (aBin[i] > 0)
      schreiben = true;
    if (schreiben == true)
      cout << aBin[i];
  }
  
  getch();
  return 0;
}


Hoffe dir geholfen zu haben :)

Gruß Chillmaster
--
With Great Power Comes Great Responsibility
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
002
05.04.2003, 14:43 Uhr
~Heiko
Gast


Musst aber aufpassen, wenn die zahlen nachkommastellen haben, dann musst du soweit ich weiss nicht mehr durch zwei teilen, sondern mit zwei multiplizieren
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
003
05.04.2003, 15:27 Uhr
Chillmaster



@ ~Heiko.
jup. Das Programm behandelt nur Ganzzahlen.
--
With Great Power Comes Great Responsibility
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
004
10.04.2003, 22:04 Uhr
~ChrisPP
Gast


Also in der Schule habe ích das so gemacht :


//----------------------------------------
do{
i++;
rest=zahl%2;
zahl=zahl/2;
cout<<"\b\b"<<rest;

if(i==4) //Damit er in 4ter schritten ausgibt um besser in Hex umzuwandeln
{
cout<<"\b";
i=0;
}

}while(zahl!=0);
//---------------------------------------

Mein Lehrer mein es gäbe standartmäßig in C++ Funktionen mit dehnen
man Hex -binär und sogar oktalzahlen umwandeln und miteinander addieren, subtrahierne etc. kann ...
!??!

Ach die Zeilen oben sind nur für Ganzzahlen.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
005
10.04.2003, 22:27 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)


Das Operationen ausführen ist für den Rechner immer gleich, da er die Zahlen in einem festgelegten Format speichert.

Es ist ihm also egal, ob du ihm z.B. eine integerzahl so

int=13; oder int=0xD übergibst.

Er speichert dann für diese Zahl einfach immer 000.......00001101
Der Rechner rechnet also im Dualsystem.
Wenn Zweierkomplementzahlen verwendet werden, wird das MSB (Most Significant Bit), also das höchstwertigste Bit negativ interpretiert.
Wenn du also z.B. ein 4 Bit zahl hättest würde das erste Bit von links als -8 interpretiert werden.
1011 wäre dann also (-8+2+1=-5 im Zweierkomplement und 8+2+1=11 sonst)


Bei Kommazahlen ist das noch ein bischen anders dort gibt es ein vorzeichenbit
Einen Bereich für den Exponenten und die Mantisse.
Die Mantisse gibt quasi die Zahl an und der Exponent gibt an um vieviele Kommastellen die Zahl zu verschieben ist.

vielleicht hilft dir das ja
--
...fleißig wie zwei Weißbrote

Dieser Post wurde am 10.04.2003 um 22:28 Uhr von Heiko editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
006
11.04.2003, 02:03 Uhr
Chillmaster




Zitat:
original von ~ChrisPP
Also in der Schule habe ích das so gemacht :


//----------------------------------------
do{
i++;
rest=zahl%2;
zahl=zahl/2;
cout<<"\b\b"<<rest;

if(i==4) //Damit er in 4ter schritten ausgibt um besser in Hex umzuwandeln
{
cout<<"\b";
i=0;
}

}while(zahl!=0);
//---------------------------------------

Mein Lehrer mein es gäbe standartmäßig in C++ Funktionen mit dehnen
man Hex -binär und sogar oktalzahlen umwandeln und miteinander addieren, subtrahierne etc. kann ...
!??!

Ach die Zeilen oben sind nur für Ganzzahlen.



Was sollen die komischen Escape - Sequenzen?
\b ist doch die Escape-Sequenz für Backspace oder?
Dein Programm schreibt also eine Zahl und löscht sie 2 oder gar 3 mal?????

Das war wohl nicht im Sinne des Erfinders

Die erste Ausgabezeile würd ich ganz ohne Leerzeichen schreiben also so:
cout << rest;

und das "\b" in der if - Anweisung würd ich mit " " ersetzen.

Noch was: Binärzahlen werden von Rechts nach links geschrieben.
Dein Programm schreibt eine 2 Binär so: 01
Richtig wäre aber: 10

EDIT:

Zitat:
original von ~ChrisPP

...

if(i==4) //Damit er in 4ter schritten ausgibt um besser in Hex umzuwandeln
{
cout<<"\b";
i=0;
}

...



Wenn du Dezimalzahlen in Hex - Zahlen umwandeln willst, machst du eigentlich genau dasselbe, bloß anstatt die Zahl % 2 zu machen machst
du Zahl % 16.
Dann mittels if oder switch - Anweisung die Buchstaben A B C D E F für die Zahlen 10 - 15 ausgeben.

Hab jetzt lust so ein Programm zu schreiben, also mach ich das einfach
--
With Great Power Comes Great Responsibility

Dieser Post wurde am 11.04.2003 um 02:16 Uhr von Chillmaster editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
007
11.04.2003, 09:52 Uhr
Chillmaster



Naja, war gestern doch zu spät.
Habs eben schnell zusammengeschustert und auch gleich nen kleinen Objektorientierten Ansatz miteingebaut :)

Ich glaub der Quelltext is nicht sehr übersichtlich, aber ihr werdet euch da schon durchwursteln ;)


C++:
#include <iostream.h>
#include <conio.h>
#include <string.h>

enum BASIS {BIN=2, OCT=8, DEZ=10, HEX=16};
class DeziFun
{
public:
// Konstruktoren
  DeziFun (unsigned long dezZahl): itsInt(dezZahl)  { };    // INLINE
  DeziFun (unsigned long dezZahl, BASIS basis, unsigned short initGroup = 4);
  ~DeziFun() { delete[] endString; };                                         // INLINE

// Zugriffsfunktionen
  unsigned long GetInt() const  { return itsInt; };
  char * GetString() const  { return endString; };
  void NewBasis (BASIS newBasis, unsigned short newGroup = 4);

private:
  void WandelUm();

  unsigned long itsInt;
  BASIS itsBasis;
  unsigned short itsGroup;
  char * endString;

};

DeziFun::DeziFun(unsigned long dezZahl, BASIS basis, unsigned short group):
itsInt(dezZahl),
itsBasis(basis),
itsGroup(group),
endString(0)
{
  WandelUm();
}

void
DeziFun::WandelUm()
{
  delete [] endString;

  const int MaxLaenge = 70;
  char tmpStr[MaxLaenge];
  unsigned long tmpInt;
  int i, aktLaenge, rest[MaxLaenge];

  if ( (itsBasis > 16) || (itsBasis < 0) )
    itsBasis = 16;

  for ( i=0; i<MaxLaenge; i++)
  {
    tmpStr[i] = ' ';
    rest[i] = -1;
  }
  tmpStr[i] = '\0';

// endString setzen
  tmpInt = itsInt;
  for ( i=0;  tmpInt != 0;  tmpInt /= itsBasis, i++ )
    rest[i] = ( tmpInt % itsBasis );
  for (; ( i % itsGroup ) != 0;  i++ )
    rest[i] = 0;

  for (  short j = 0, i = MaxLaenge - 1;  i >= 0; j++, i-- )
    switch ( rest[i] )
    {
     case -1: break;
     case 10: tmpStr[j] = 'A'; break;
     case 11: tmpStr[j] = 'B'; break;
     case 12: tmpStr[j] = 'C'; break;
     case 13: tmpStr[j] = 'D'; break;
     case 14: tmpStr[j] = 'E'; break;
     case 15: tmpStr[j] = 'F'; break;
     default: tmpStr[j] = char( rest[i] + 48 );
    }
  for (i=0; rest[i] != -1; )
    i++;
  aktLaenge = i+1;
  endString = new char[aktLaenge + (aktLaenge / itsGroup) + 1 ];
  for (short j=0, i=0;  i < aktLaenge; j++, i++)
  {
    if ( (i % itsGroup == 0) && i )
    {
      endString[j] = ' ';
      j++;
    }
    endString[j] = tmpStr[MaxLaenge-aktLaenge+1+i];
  }
  endString[aktLaenge+1] = '\0';
}

void
DeziFun::NewBasis (BASIS newBasis, unsigned short newGroup)
{
  itsBasis = newBasis;  itsGroup = newGroup;
  WandelUm();
}

//  **********  RAHMENPROGRAMM  ***************
int main()
{
  unsigned long dez;
  cout << "Bitte eine Dezimalzahl eingeben, welche umgewandelt werden soll: ";
  cin >> dez;
  DeziFun * Zahl1 = new DeziFun(dez, BIN, 8);
  cout << "\n\nBinaer:\t\t" << Zahl1->GetString() << endl;
  Zahl1->NewBasis(OCT, 2);
  cout << "\nOktal:\t\t" << Zahl1->GetString() << endl;
  Zahl1->NewBasis(DEZ, 3);
  cout << "\nDezimal:\t" << Zahl1->GetString() << endl;
  Zahl1->NewBasis(HEX, 4);
  cout << "\nHexadezimal:\t" << Zahl1->GetString() << endl;

  getch();
  return 0;
}


Das Programm wandelt mittels Klassen Dezimalzahlen in Zahlen von der Basis 2 - 16 um.
--
With Great Power Comes Great Responsibility

Dieser Post wurde am 11.04.2003 um 09:56 Uhr von Chillmaster editiert.
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
008
04.11.2004, 00:39 Uhr
~outlaw_wolf
Gast


Also, ich habe grade erst mit C++ angefangen und dafür auch ewig gebraucht:
Aber so kann man beides umwandeln



Code:
#include <iostream>
using namespace std;

int main ()
{
    // convert a binary figure into a decimal one

    int binary, sum=0, i=1;
    
    cout << "Bitte geben Sie die Bin\x84rzahl ein." << endl;
    cout << "Beachten sie, dass diese nur 10-stellig sein kann:" << endl;
    cout << "Eingabe: ";
    cin >> binary;
    
    while (binary>0)
    {
        sum += (binary%10)*i;
        binary = binary/10;
        i *= 2;
    }
    
    cout << endl << "Der Dezimalwert ist: " << sum << endl;
    
    
    
    // convert a decimal fuigur inti a binary one
    
    int deci, summ=0, j=1;
    
    
    cout << "Bitte geben Sie die Dezimalzahl ein." << endl;
    cout << "Eingabe: ";
    cin >> deci;
    
    
    while (deci>0)
    {
        summ += (deci%2)*j;
        deci = deci /2;
        j *=10;    
    }
    
    cout << endl << "Der Bin\x84rwert der Zahl lautet: ";
    cout << summ << endl;
    
    
    return 0;
}

 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
009
16.11.2004, 13:59 Uhr
~return
Gast


müsste auch so ähnlich in Delphi klappen, oder?
 
Profil || Private Message || Suche Download || Zitatantwort || Editieren || Löschen || IP
Seiten: > 1 <     [ Borland C++ Builder ]  


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: