Zahlen umwandeln (Bin, Oct, Dec, Hex)

[Morlon]

Hi,

ich hab mir grad mühevoll ein kleines Progi geschrieben mit dem ich Binär, Oktal, Dezimal und HexaDezimal umwandeln kann wie ich lustig bin. Da ich das ohne eure schönes Forum hier nich geschafft hätte und da ich gesehn hab dass es x posts gibt in denen nach solchen umwandlungen gefragt wurde denk ich ist es nich mehr als fair wenn ich das progi mal poste :wink:
Die eine oder andere Zeile kommt euch sicherlich bekannt vor, aber alles in allem hab ichs doch irgendwie selbst zusammen geknaupt :P
Man kann sicherlich noch einiges dran optimieren, vor allem, weil ich noch nich so sehr viele befehle kenn, was man sicherlich auch merken wird, aber es funktioniert :) also hier mal der Quelltext:

Delphi-Quellcode:

unit Zahlwandler1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls;

type
  TForm1 = class(TForm)
    GroupBox1: TGroupBox;
    RadioButton1: TRadioButton;
    RadioButton2: TRadioButton;
    RadioButton3: TRadioButton;
    RadioButton4: TRadioButton;
    Button1: TButton;
    Button2: TButton;
    Button3: TButton;
    Edit1: TEdit;
    GroupBox2: TGroupBox;
    RadioButton5: TRadioButton;
    RadioButton6: TRadioButton;
    RadioButton7: TRadioButton;
    RadioButton8: TRadioButton;
    Label1: TLabel;
    procedure Button3Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

uses StrUtils;

  type typBin = Array[1..100] of Boolean;
  var arrBin: typBin;

{$R *.dfm}

//*************************************************************************
//                           ARRAY LEEREN
//*************************************************************************
procedure ArrClear(PArr: typBin);
var i: integer;
begin
  for i := 1 to 100 do arrBin[i] := False;
end;

//*************************************************************************
//                           POTENZIEREN
//*************************************************************************
function potenziren(FWert: integer): integer;
var i: integer;
begin
  if FWert = 0 then result := 1 else result := 2;
  for i := 1 to FWert - 1 do result := result * 2;
end;

//*************************************************************************
//                            Dezimal => Binär
//*************************************************************************
function FDecToBin(FWert: String): String;
var i, FIntWert, Counter, BinStellen: Integer;
    bolSchleife, bolErstlauf: Boolean;
begin
  Result := '';
  bolErstlauf := True;
  FIntWert := StrToInt(FWert);
  while FIntWert > 0 do
    begin
      i := 1;
      Counter := 0;
      bolSchleife := True;
      while bolSchleife = True do
        begin
          if i * 2  <= FIntWert then
            i := i * 2
          else
            bolSchleife := False;
          Counter := Counter + 1;
        end;
      if bolErstlauf = true then BinStellen := Counter;
      bolErstlauf := False;
      arrBin[Counter] := True;
      FIntWert := FIntWert - i;
    end;
  for i := BinStellen  downto 1 do
    if arrBin[i] = true then Result := Result + '1' else Result := Result + '0';
  ArrClear(arrBin);
end;

//*************************************************************************
//                            HexaDezimal => Dezimal
//*************************************************************************
function FHexToDec(FWert: String): String;
begin
  FWert := '$' + FWert;
  Result := InttoStr(StrToInt(FWert));
end;

//*************************************************************************
//                            Oktal => Dezimal
//*************************************************************************
function FOctToDec(FWert: String): String;
var i, ZwErg: Integer;
begin 
  ZwErg := 0;
  for i := 1 to Length(FWert) do
    begin
      ZwErg := ZwErg * 8 +(Byte(FWert[i]) - Byte('0'));
    end;
  Result := IntToStr(ZwErg);
end;

//*************************************************************************
//                            Dezimal => Oktal
//*************************************************************************
function FDecToOct(FWert: String): String;
var ZwErg1: Integer;
    ZwErg2: String;
    FIntWert: Integer;
begin
  FIntWert := StrToInt(FWert);
  ZwErg2 := '';
  while FIntWert > 0 do
    begin
      ZwErg1 := FIntWert mod 8;
      FIntWert := FIntWert div 8;
      ZwErg2 := IntToStr(ZwErg1) + ZwErg2;
  end;
  Result := ZwErg2;
end;

//*************************************************************************
//                            Binär => Dezimal
//*************************************************************************
function FBinToDec(FWert: String): String;
var i, ZwErg: integer;
begin
  ZwErg := 0;
  for i := 1 to Length(FWert) do
    ZwErg := ZwErg + strtoint(FWert[i]) * potenziren(Length(FWert)-i);
  Result := inttostr(ZwErg);
end;

//*************************************************************************
//                            Binär => HexaDezimal
//*************************************************************************
function FBinToHex(FWert: String): String;
var ZwErgStr: String;
    ZwErgInt: Double;
    arrIndex: Integer;
const arrHex: array[0..15] of Char = ('0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F');
begin
  while Length(FWert) > 0 do
      if Length(FWert) > 4 then
        begin
          ZwErgInt := strtoint(FBinToDec(RightStr(FWert,4)));
          FWert := LeftStr(FWert,Length(FWert)-4);
          ZwErgStr := FloatToStr(ZwErgInt);
          arrIndex := Strtoint(ZwErgStr);
          Result := arrHex[arrIndex] + Result;
        end
      else
        begin
          ZwErgInt := strtoint(FBinToDec(FWert));
          FWert := '';
          ZwErgStr := FloatToStr(ZwErgInt);
          arrIndex := Strtoint(ZwErgStr);
          Result := arrHex[arrIndex] + Result;
        end
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
  close;
end;

procedure TForm1.Button2Click(Sender: TObject);
begin
  RadioButton1.Checked := True;
  RadioButton5.Checked := True;
  Label1.Caption := '';
  Edit1.Clear;
end;

procedure TForm1.Button1Click(Sender: TObject);
var i: integer;
    bolPruef: Boolean;
begin

  bolPruef := True;

  if RadioButton1.Checked = true then
    begin
      for i := 1 to Length(Edit1.Text) do
        if Edit1.Text[i] <> '0' then
          if Edit1.Text[i] <> '1' then
            bolPruef := False;
      if bolPruef = True then
        begin
          if RadioButton5.Checked = true then Label1.Caption := Edit1.Text;
          if RadioButton6.Checked = true then Label1.Caption := FDecToOct(FBinToDec(Edit1.Text));
          if RadioButton7.Checked = true then Label1.Caption := FBinToDec(Edit1.Text);
          if RadioButton8.Checked = true then Label1.Caption := FBinToHex(Edit1.Text);
        end
      else
        Label1.Caption := 'Wert nicht Binär';
    end;

  if RadioButton2.Checked = true then
    begin
      for i := 1 to Length(Edit1.Text) do
        if Edit1.Text[i] <> '0' then
          if Edit1.Text[i] <> '1' then
            if Edit1.Text[i] <> '2' then
              if Edit1.Text[i] <> '3' then
                if Edit1.Text[i] <> '4' then
                  if Edit1.Text[i] <> '5' then
                    if Edit1.Text[i] <> '6' then
                      if Edit1.Text[i] <> '7' then
                       bolPruef := False;
      if bolPruef = True then
        begin
          if RadioButton5.Checked = true then Label1.Caption := FDecToBin(FOctToDec(Edit1.Text));
          if RadioButton6.Checked = true then Label1.Caption := Edit1.Text;
          if RadioButton7.Checked = true then Label1.Caption := FOctToDec(Edit1.Text);
          if RadioButton8.Checked = true then Label1.Caption := FBinToHex(FDecToBin(FOctToDec(Edit1.Text)));
        end
      else
        Label1.Caption := 'Wert nicht Oktal';
    end;

  if RadioButton3.Checked = true then
    begin
      for i := 1 to Length(Edit1.Text) do
        if Edit1.Text[i] <> '0' then
          if Edit1.Text[i] <> '1' then
            if Edit1.Text[i] <> '2' then
              if Edit1.Text[i] <> '3' then
                if Edit1.Text[i] <> '4' then
                  if Edit1.Text[i] <> '5' then
                    if Edit1.Text[i] <> '6' then
                      if Edit1.Text[i] <> '7' then
                        if Edit1.Text[i] <> '8' then
                          if Edit1.Text[i] <> '9' then
                            bolPruef := False;
      if bolPruef = True then
        begin
      if RadioButton5.Checked = true then Label1.Caption := FDecToBin(Edit1.Text);
      if RadioButton6.Checked = true then Label1.Caption := FDecToOct(Edit1.Text);
      if RadioButton7.Checked = true then Label1.Caption := Edit1.Text;
      if RadioButton8.Checked = true then Label1.Caption := FBinToHex(FDecToBin(Edit1.Text));
        end
      else
        Label1.Caption := 'Wert nicht Dezimal';
    end;

  if RadioButton4.Checked = true then
    begin
      for i := 1 to Length(Edit1.Text) do
        if Edit1.Text[i] <> '0' then
          if Edit1.Text[i] <> '1' then
            if Edit1.Text[i] <> '2' then
              if Edit1.Text[i] <> '3' then
                if Edit1.Text[i] <> '4' then
                  if Edit1.Text[i] <> '5' then
                    if Edit1.Text[i] <> '6' then
                      if Edit1.Text[i] <> '7' then
                        if Edit1.Text[i] <> '8' then
                          if Edit1.Text[i] <> '9' then
                            if Edit1.Text[i] <> 'A' then
                              if Edit1.Text[i] <> 'B' then
                                if Edit1.Text[i] <> 'C' then
                                  if Edit1.Text[i] <> 'D' then
                                    if Edit1.Text[i] <> 'E' then
                                      if Edit1.Text[i] <> 'F' then
                                        if Edit1.Text[i] <> 'a' then
                                          if Edit1.Text[i] <> 'b' then
                                            if Edit1.Text[i] <> 'c' then
                                              if Edit1.Text[i] <> 'd' then
                                                if Edit1.Text[i] <> 'e' then
                                                  if Edit1.Text[i] <> 'f' then
                                                    bolPruef := False;
      if bolPruef = True then
        begin
      if RadioButton5.Checked = true then Label1.Caption := FDecToBin(FHexToDec(Edit1.Text));
      if RadioButton6.Checked = true then Label1.Caption := FDecToOct(FHexToDec(Edit1.Text));
      if RadioButton7.Checked = true then Label1.Caption := FHexToDec(Edit1.Text);
      if RadioButton8.Checked = true then Label1.Caption := Edit1.Text;
        end
      else
        Label1.Caption := 'Wert nicht Hexa';
    end;
end;

end.

Um das Ding zum laufen zu bekommen braucht ihr 3 Buttons (Button1 = Ausgabe, Button2 = Clear, Button3 = Beenden), 8 RadioButtons (1-4 Bin, Oct, Dez, Hex eingabewert, 5-8 Bin, Oct, Dez, Hex ausgabewert), ein editfeld zur eingabe und ein label zur ausgabe.... ich hab noch 2 groupbox drin, damits schön aussieht, könnt ihr aber auch rausschmeißen ;P

Viel Spaß damit...
Elmar

[Luckie]

Warum hängst du das nicht als komplettes Projekt an?

Ich habe nur mal grob drübergekuckt:

Delphi-Quellcode:

Result := InttoStr(StrToInt(FWert));

Wenn man versteht, was man da zusammenkopiert, dann sollte so ein Unsinn nicht bei raus kommen.

Delphi-Quellcode:

 if RadioButton2.Checked = true then
    begin
      for i := 1 to Length(Edit1.Text) do
        if Edit1.Text[i] <> '0' then
          if Edit1.Text[i] <> '1' then
            if Edit1.Text[i] <> '2' then
              if Edit1.Text[i] <> '3' then
                if Edit1.Text[i] <> '4' then
                  if Edit1.Text[i] <> '5' then
                    if Edit1.Text[i] <> '6' then
                      if Edit1.Text[i] <> '7' then

Mir erschließt sich nicht ganz der Sinn, aber das geht bestimmt auch einfacher und eleganter.

[DaFox]

Hi!

Zitat:

Zitat von Luckie

Delphi-Quellcode:

Result := InttoStr(StrToInt(FWert));

Wenn man versteht, was man da zusammenkopiert, dann sollte so ein Unsinn nicht bei raus kommen.

Zitat:

Zitat von Morlon

Delphi-Quellcode:

//*************************************************************************
//                            HexaDezimal => Dezimal
//*************************************************************************
function FHexToDec(FWert: String): String;
begin
  FWert := '$' + FWert;
  Result := InttoStr(StrToInt(FWert));
end;

:arrow:

Zitat:

Zitat von Die Onlinehilfe

StrToInt konvertiert den in S angegebenen String in einen Integer-Wert. S muß die Entsprechung eines ganzzahligen Wertes (dezimal oder hexadezimal) sein. Enhält er keinen gültigen Wert, wird eine EConvertError-Exception ausgelöst.

Desweiteren schreibt die Onlinehilfe:

IntToStr konvertiert den mit Value angegebenen Integer-Wert in einen String mit der dezimalen Darstellung der Zahl.

Gruß,
Markus

[dizzy]

Dieser Ultrakrampf hier (;))...

Zitat:

Zitat von Morlon

Delphi-Quellcode:

        if Edit1.Text[i] <> '0' then
          if Edit1.Text[i] <> '1' then
            if Edit1.Text[i] <> '2' then
              if Edit1.Text[i] <> '3' then
                if Edit1.Text[i] <> '4' then
                  if Edit1.Text[i] <> '5' then
                    if Edit1.Text[i] <> '6' then
                      if Edit1.Text[i] <> '7' then
                        if Edit1.Text[i] <> '8' then
                          if Edit1.Text[i] <> '9' then
                            if Edit1.Text[i] <> 'A' then
                              if Edit1.Text[i] <> 'B' then
                                if Edit1.Text[i] <> 'C' then
                                  if Edit1.Text[i] <> 'D' then
                                    if Edit1.Text[i] <> 'E' then
                                      if Edit1.Text[i] <> 'F' then
                                        if Edit1.Text[i] <> 'a' then
                                          if Edit1.Text[i] <> 'b' then
                                            if Edit1.Text[i] <> 'c' then
                                              if Edit1.Text[i] <> 'd' then
                                                if Edit1.Text[i] <> 'e' then
                                                  if Edit1.Text[i] <> 'f' then
                                                    bolPruef := False;

...lässt sich auch irre elegant schreiben:

Delphi-Quellcode:

  if not ((Edit1.Text[i] in ['0'..'9']) or (Edit1.Text[i] in ['A'..'F']) or (Edit1.Text[i] in ['a'..'f'])) then
    bolPruef := false;

;)

Nachti,
Fabian

btw: Herzlich wilkommen! :dp:

[Luckie]

Zitat:

Zitat von DaFox

Zitat:

Zitat von Die Onlinehilfe

StrToInt konvertiert den in S angegebenen String in einen Integer-Wert. S muß die Entsprechung eines ganzzahligen Wertes (dezimal oder hexadezimal) sein. Enhält er keinen gültigen Wert, wird eine EConvertError-Exception ausgelöst.

Desweiteren schreibt die Onlinehilfe:

IntToStr konvertiert den mit Value angegebenen Integer-Wert in einen String mit der dezimalen Darstellung der Zahl.

Ich halte mit

Delphi-Quellcode:

function FHexToDec(FWert: Integer): String;
begin
  Result := Format('%d', [FWert]);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  ShowMessage(FHexToDec($B6));
end;

dagegen. ;)

[negaH]

Nungut über die Qualität des Ursprungsposting lässt sich streiten ;)
aber, Zitat: "Dieser Ultrakrampf" hier...

Delphi-Quellcode:

 if not ((Edit1.Text[i] in ['0'..'9']) or (Edit1.Text[i] in ['A'..'F']) or (Edit1.Text[i] in ['a'..'f'])) then 
    bolPruef := false;

...lässt sich nicht nur irre elegant schreiben, sondern sogar viel einfacher:

Delphi-Quellcode:

bolPruef := Edit1.Text[i] in ['0'..'9', 'a'..'f', 'A'..'F'];

:)

Gruß Hagen

[Jasocul]

Wenn wir schon dabei sind:

Delphi-Quellcode:

  bolPruef := UpCase(Edit1.Text[i]) in ['0'..'9', 'A'..'F'];

:wink:

[dizzy]

Zitat:

Zitat von negaH

[...] sondern sogar viel einfacher:

Delphi-Quellcode:

bolPruef := Edit1.Text[i] in ['0'..'9', 'a'..'f', 'A'..'F'];

:)

:oops: Es gibt Uhrzeiten, da fallen einem nichmal mehr die Möglichkeiten von Mengenschreibweisen ein... :stupid:

[Morlon]

Wie ich sagte, bin noch Delphi Anfänger und man könnte das bestimmt auch eleganter lösen ;)

Ich überarbeite das ganze nochmal mit euren Tips... danke euch ;)

Achja, weiß jemand ob ich das hier eleganter lösen kann:

Delphi-Quellcode:

          ZwErgStr := FloatToStr(ZwErgInt); 
          arrIndex := Strtoint(ZwErgStr); 
          Result := arrHex[arrIndex] + Result;

Result := arrHex[ZwErgInt] + Result; macht er leider nicht, da ZwErg nen Double ist und er den nicht als Index für mein Array annehmen mag, allerdings ist die Double IMMER ne ganzzahl... weiß wer wie ich dem ohne das rumformatieren sagen kann er soll den double nehmen?

[SubData]

Ich möchte hiermit mal den guten Willen loben, egal wie """schlecht""" der Quellcode auch sein mag...
Es gibt hier immerhin genug Leute, die immer verlangen aber nie geben, und das hier ist wenigstens ein Beweis, dass es auch anders geht...

Auch wenn der Code nicht perfekt ist: Ein Lob von mir!

:dp:

[Morlon]

Also hier der überarbeitete Quelltext mit vielem Kommentaren, damit auch jeder versteht was gemacht wird ;)

Grüße
Elmar

[Gollum]

Hallo,

Zitat:

Zitat von Morlon

... Result := arrHex[ZwErgInt] + Result; ...

geht so:

Delphi-Quellcode:

Result := arrHex[Trunc(ZwErgInt)] + Result;

[Oxmyx]

Delphi-Quellcode:

procedure ArrClear(PArr: typBin);
var i: integer;
begin
  for i := 1 to 100 do arrBin[i] := False;
end;

geht viel schneller:

Delphi-Quellcode:

ZeroMemory(@arrBin, sizeof(arrBin));

[Gollum]

Hallo,

statt

Zitat:

Zitat von Oxmyx

ZeroMemory(@arrBin, sizeof(arrBin));

kann man auch

Delphi-Quellcode:

FillChar(arrBin, SizeOf(arrBin), 0);

verwenden, da ZeroMemory auch nichts anderes macht.

[Morlon]

huch, falscher Knopf, bitte löschen. :shock:

[MaBuSE]

Zitat:

Zitat von Morlon

ich hab mir grad mühevoll ein kleines Progi geschrieben mit dem ich Binär, Oktal, Dezimal und HexaDezimal umwandeln kann wie ich lustig bin.

Warum schreibst Du nicht eine Funktion, die von jeder Basis in jede Basis wandeln kann?

Wenn Du z.B. die Dezimalzahl 1347605150 in ein Zahlensystem der Basis 36 wandeln möchtest, dann würde das auch gehen. (Basis 36 = Ziffer 0..9 und A..Z -> 10 wäre dann also 36, 11 = 37, 0Z = 35, ...)

Delphi-Quellcode:

function X2Y(BaseX, BaseY: Byte; BaseXZahl: string):string;

Falls jemand unbedingt eine Funktion Hex nach Bin bräuchte:

Delphi-Quellcode:

function hex2bin(hex:string):string;
begin
  Result := x2y(16, 2, hex);
end;

Das ist doch der einfachste Weg, oder?

[MaBuSE]

Zitat:

Zitat von MaBuSE

die Dezimalzahl 1347605150 in ein Zahlensystem der Basis 36 wandeln

(Anmerkung: dec = Dezimales Zahlensstem = das mit dem wir rechnen)

In Base36 gibt es die Ziffern:

Code:

0 = 0
1 = 1
2 = 2
3 = 3
4 = 4
5 = 5
6 = 6
7 = 7
8 = 8
9 = 9
A = 10
B = 11
C = 12
D = 13
E = 14
F = 15
G = 16
H = 17
I = 18
J = 19
K = 20
L = 21
M = 22
N = 23
O = 24
P = 25
Q = 26
R = 27
S = 28
T = 29
U = 30
V = 31
W = 32
X = 33
Y = 34
Z = 35

Zahlen werden wie folgt zusammengesetzt:

Code:

2X3 in Base36 

2X3
= 2 * 36^2 + 33 * 36^1 + 3 * 36^0 (in dec)
= 3888 + 1188 + 3 (in dec)
= 5079 (in dec)

Hier noch mal die Umrechnungstabelle

Code:

36^0 = 1
36^1 = 36
36^2 = 1296
36^3 = 46656
36^4 = 1679616
36^5 = 60466176

Beispiel: 1347605150 (dec) nach Base36

Code:

MABUSE (base32)
= 22 * 36^5 + 10 * 36^4 + 11 * 36^3 + 30 * 36^2 + 28 * 36^1 + 14 * 36^0 (in dec)
= 1330255872 + 16796160 + 513216 + 38880 + 1008 + 14 (in dec)
= 1347605150 (in dec)

[Helmi]

Hallo,

das ist ja ein ganz nettes Programm!! :thumb:

Nur... - da hat sich wohl der Fehlerteufel ein wenig eingeschlichen (siehe Anhang) :coder2:

Wenn ich damals in meiner Ausbildung richtig aufgepasst hab dann gibts Binär die Zahl "4" nicht.

mfg
Helmi

[edit]Huch - Attachment vergessen! - Das blöde Alter :wink: [/edit]

[MaBuSE]

Zitat:

Zitat von MaBuSE

Zitat:

Zitat von Morlon

ich hab mir grad mühevoll ein kleines Progi geschrieben mit dem ich Binär, Oktal, Dezimal und HexaDezimal umwandeln kann wie ich lustig bin.

Warum schreibst Du nicht eine Funktion, die von jeder Basis in jede Basis wandeln kann?

Wenn Du z.B. die Dezimalzahl 1347605150 in ein Zahlensystem der Basis 36 wandeln möchtest, dann würde das auch gehen. (Basis 36 = Ziffer 0..9 und A..Z -> 10 wäre dann also 36, 11 = 37, 0Z = 35, ...)

Delphi-Quellcode:

function X2Y(BaseX, BaseY: Byte; BaseXZahl: string):string;

Falls jemand unbedingt eine Funktion Hex nach Bin bräuchte:

Delphi-Quellcode:

function hex2bin(hex:string):string;
begin
  Result := x2y(16, 2, hex);
end;

Das ist doch der einfachste Weg, oder?

So, ich habe mal eben schnell eine X2Y Funktion geschrieben:

Da ich keine Addition und Multiplikation für base2 bis base36 zur Verfügung habe,
mache ich den Umweg über das Dezimalsystem.
Die Zahlen werden erst von Basis X nach dec umgerechnet und danach von dec zu Basis Y.
Das war auf die schnelle der einfachste Weg (für mich)
Auserdem habe ich mich für IntPower entschieden (x hoch y), da es schneller geht als ein

Delphi-Quellcode:

a := b * b * b * b * ... * b;

Kritik willkommen ;-)

Delphi-Quellcode:

uses math;

(*
// IntPower ist in der Unit Math von Delphi 7 enthalten
// Copyright (c) 1996, 2001 Borland Software Corporation
function IntPower(const Base: Extended; const Exponent: Integer): Extended;
asm
        mov     ecx, eax
        cdq
        fld1                      { Result := 1 }
        xor     eax, edx
        sub     eax, edx          { eax := Abs(Exponent) }
        jz      @@3
        fld     Base
        jmp     @@2
@@1:    fmul    ST, ST            { X := Base * Base }
@@2:    shr     eax,1
        jnc     @@1
        fmul    ST(1),ST          { Result := Result * X }
        jnz     @@1
        fstp    st                { pop X from FPU stack }
        cmp     ecx, 0
        jge     @@3
        fld1
        fdivrp                    { Result := 1 / Result }
@@3:
        fwait
end;
*)

// 22.12.2004 MaBuSE: X2Y wandelt in der BasisX angegebene Zahl nach BasisY um
//                    created for [url]www.delphipraxis.net[/url]
function X2Y(BaseX, BaseY: Byte; BaseXZahl: string):string;
const
  Ziffern = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';
var
  i: Integer;
  Base10Zahl: Int64;
begin
  // Parameter in Ordnung ?
  Assert((BaseX<=36) and (BaseY<=36), 'Basis ist größer 36');
  BaseXZahl := UpperCase(BaseXZahl);
  i := Length(BaseXZahl);
  while (i>0) and (pos(BaseXZahl[i], copy(Ziffern, 1, BaseX))>0) do
  begin
    dec(i);
  end;
  Assert(i=0, 'BaseXZahl enhällt ungültige Ziffern');

  // Umrechnen BaseX nach dec
  Base10zahl := 0;
  for i := 1 to Length(BaseXZahl) do
  begin
    Base10Zahl := Base10zahl +
                  (Round(IntPower(BaseX, length(BaseXZahl)-i)) *
                  (Pos(BaseXZahl[i], Ziffern)-1));
  end;

  // Umrechnen dec nach BaseY
  Result := '';
  i := 0;
  while Base10Zahl >= IntPower(BaseY, i) do
  begin
    inc(i);
  end;
  while i>0 do
  begin
    Result := Result + Ziffern[Base10Zahl div Round(IntPower(BaseY, i-1))+1];
    Base10zahl := Base10Zahl mod Round(IntPower(BaseY, i-1));
    dec(i);
  end;
end;

// zum Test einfach einen Button aufs Formular ;-)
procedure TForm1.Button1Click(Sender: TObject);
begin
  Button1.Caption := X2Y(10, 36, '1347605150');
end;

Für die die dann doch einzelne Funktionen wollen:

Delphi-Quellcode:

// bin nach xxx
function bin2hex(bin:string):string;
begin
  Result := x2y(2, 16, bin);
end;

function bin2dec(bin:string):string;
begin
  Result := x2y(2, 10, bin);
end;

function bin2oct(bin:string):string;
begin
  Result := x2y(2, 8, bin);
end;

// oct nach xxx
function oct2hex(oct:string):string;
begin
  Result := x2y(8, 16, oct);
end;

function oct2dec(oct:string):string;
begin
  Result := x2y(8, 10, oct);
end;

function oct2bin(oct:string):string;
begin
  Result := x2y(8, 2, oct);
end;

// dec nach xxx
function dec2hex(dec:string):string;
begin
  Result := x2y(10, 16, dec);
end;

function dec2oct(dec:string):string;
begin
  Result := x2y(10, 8, dec);
end;

function dec2bin(dec:string):string;
begin
  Result := x2y(10, 2, dec);
end;

// hex nach xxx
function hex2dec(hex:string):string;
begin
  Result := x2y(16, 10, hex);
end;

function hex2oct(hex:string):string;
begin
  Result := x2y(16, 8, hex);
end;

function hex2bin(hex:string):string;
begin
  Result := x2y(16, 2, hex);
end;

So ich hoffe es hilft evtl jemanden
Viel Spaß

[edit]
ps: Ich habe mal ein kleines Beispielprogramm erzeugt. (Anhang)
[/edit]

[Morlon]

Ich hatte das Progi unter Open-Source hinzugefügt, und da hat doch glatt jemand ein kleines Progi geschrieben (und es ist wirklich klein) dass Dezimal in alles umwandeln kann.

Kuckst du hier :)