специфический калькулятор на Делфи

[berkutua]

Доброе время суток.
Вопрос по курсовой. Нужно сделать в Делфи калькулятор, который переводит из 16 сс в 2, 8, и 10 сс.
Задача казалось бы и легка, но есть нюансы. Мой алгоритм: вводимое число разбить на разряды а потом по отдельности сравнивать с библиотекой (когда переводим из 16сс в 2сс). Например 12А разбить на 1,2, и А. Проблема заключается в том, как это сделать? Как это записать в Делфи…? Может это и не самый лучший вариант, может есть и лучше. Буду очень благодарен за любую помощь, за любой алгоритм.

ЗЫ Если не там постанул(не в том разделе), извеняюсь.

 

[berkutua]

Никто не знает?

 

[Barmutik]

Ну какие проблемы .. не вдаваясь в Ваши алгоритмы.. просто обращайтесь к Вашей строке по одному символу и получите то что Вам надо ..

По секрету сообщу что есть в Дельфях готовые функции для перевода чисел в разные системы счисления

Хотя и напистаь их в принципе дело часа..

 

[berkutua]

По секрету сообщу что есть в Дельфях готовые функции для перевода чисел в разные системы счисления

Вот это уже интересно, можно подробнее? Плиз. Или хотябы пояснить

просто обращайтесь к Вашей строке по одному символу и получите то что Вам надо ...

 

[berkutua]

нашел ф-ю, только не пойму...как будет выглядить полностью исходник с этой вот ф-ей?

function HexToBin(Text, Buffer: PChar; BufSize: Integer): Integer;
const
Convert: array[′0′..′f′] of SmallInt =
( 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1,
-1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
-1,10,11,12,13,14,15);
var
I: Integer;
begin
I := BufSize;
while I > 0 do
begin
if not (Text[0] in [′0′..′f′]) or not (Text[1] in [′0′..′f′]) then Break;
Buffer[0] := Char((Convert[Text[0]] shl 4) + Convert[Text[1]]);
Inc(Buffer);
Inc(Text, 2);
Dec(I);
end;
Result := BufSize - I;
end;

 

[berkutua]

ну подскажите же. для вас это должно быть как 2х2.

 

[vital]

Держи готовый Unit с функциями для перевода и не морочь голову ни себе ни людям..

unit CONVUNIT;

interface

function DEC2BIN(DEC: LONGINT): string;
function BIN2DEC(BIN: string): LONGINT;
function DEC2HEX(DEC: LONGINT): string;
function HEX2DEC(HEX: string): LONGINT;
function DEC2OCT(DEC: LONGINT): string;
function OCT2DEC(OCT: string): LONGINT;
function BIN2HEX(BIN: string): string;
function HEX2BIN(HEX: string): string;
function DEC2BASEN(BASE: INTEGER; DEC: LONGINT): string;// эта функция конвертит ИЗ десятичной в разные системы счисления от 2-х до 36-ти.
function BASEN2DEC(BASE: INTEGER; NUM: string): LONGINT;//эта ф-ция конвертит В десятичную из разных систем счисления. От 2-х до 36-ти.

implementation

function DEC2BIN(DEC: LONGINT): string;

var
BIN: string;
I, J: LONGINT;

begin
if DEC = 0 then
BIN := '0'
else
begin
BIN := '';
I := 0;
while (1 shl (I + 1)) < = DEC do
I := I + 1;
{ (1 SHL (I + 1)) = 2^(I + 1) }
for J := 0 to I do
begin
if (DEC shr (I - J)) = 1 then
BIN := BIN + '1'
{ (DEC SHR (I - J)) = DEC DIV 2^(I - J) }
else
BIN := BIN + '0';
DEC := DEC and ((1 shl (I - J)) - 1);
{ DEC AND ((1 SHL (I - J)) - 1) = DEC MOD 2^(I - J) }
end;
end;
DEC2BIN := BIN;
end;

function BIN2DEC(BIN: string): LONGINT;

var
J: LONGINT;
Error: BOOLEAN;
DEC: LONGINT;

begin
DEC := 0;
Error := False;
for J := 1 to Length(BIN) do
begin
if (BIN[J] < > '0') and (BIN[J] < > '1') then
Error := True;
if BIN[J] = '1' then
DEC := DEC + (1 shl (Length(BIN) - J));
{ (1 SHL (Length(BIN) - J)) = 2^(Length(BIN)- J) }
end;
if Error then
BIN2DEC := 0
else
BIN2DEC := DEC;
end;

function DEC2HEX(DEC: LONGINT): string;

const
HEXDigts: string[16] = '0123456789ABCDEF';

var
HEX: string;
I, J: LONGINT;

begin
if DEC = 0 then
HEX := '0'
else
begin
HEX := '';
I := 0;
while (1 shl ((I + 1) * 4)) < = DEC do
I := I + 1;
{ 16^N = 2^(N * 4) }
{ (1 SHL ((I + 1) * 4)) = 16^(I + 1) }
for J := 0 to I do
begin
HEX := HEX + HEXDigts[(DEC shr ((I - J) * 4)) + 1];
{ (DEC SHR ((I - J) * 4)) = DEC DIV 16^(I - J) }
DEC := DEC and ((1 shl ((I - J) * 4)) - 1);
{ DEC AND ((1 SHL ((I - J) * 4)) - 1) = DEC MOD 16^(I - J) }
end;
end;
DEC2HEX := HEX;
end;

function HEX2DEC(HEX: string): LONGINT;

function Digt(Ch: CHAR): BYTE;

const
HEXDigts: string[16] = '0123456789ABCDEF';

var
I: BYTE;
N: BYTE;

begin
N := 0;
for I := 1 to Length(HEXDigts) do
if Ch = HEXDigts[I] then
N := I - 1;
Digt := N;
end;

const
HEXSet: set of CHAR = ['0'..'9', 'A'..'F'];

var
J: LONGINT;
Error: BOOLEAN;
DEC: LONGINT;

begin
DEC := 0;
Error := False;
for J := 1 to Length(HEX) do
begin
if not (UpCase(HEX[J]) in HEXSet) then
Error := True;
DEC := DEC + Digt(UpCase(HEX[J])) shl ((Length(HEX) - J) * 4);
{ 16^N = 2^(N * 4) }
{ N SHL ((Length(HEX) - J) * 4) = N * 16^(Length(HEX) - J) }
end;
if Error then
HEX2DEC := 0
else
HEX2DEC := DEC;
end;

function DEC2OCT(DEC: LONGINT): string;

const
OCTDigts: string[8] = '01234567';

var
OCT: string;
I, J: LONGINT;

begin
if DEC = 0 then
OCT := '0'
else
begin
OCT := '';
I := 0;
while (1 shl ((I + 1) * 3)) < = DEC do
I := I + 1;
{ 8^N = 2^(N * 3) }
{ (1 SHL (I + 1)) = 8^(I + 1) }
for J := 0 to I do
begin
OCT := OCT + OCTDigts[(DEC shr ((I - J) * 3)) + 1];
{ (DEC SHR ((I - J) * 3)) = DEC DIV 8^(I - J) }
DEC := DEC and ((1 shl ((I - J) * 3)) - 1);
{ DEC AND ((1 SHL ((I - J) * 3)) - 1) = DEC MOD 8^(I - J) }
end;
end;
DEC2OCT := OCT;
end;

function OCT2DEC(OCT: string): LONGINT;

const
OCTSet: set of CHAR = ['0'..'7'];

var
J: LONGINT;
Error: BOOLEAN;
DEC: LONGINT;

begin
DEC := 0;
Error := False;
for J := 1 to Length(OCT) do
begin
if not (UpCase(OCT[J]) in OCTSet) then
Error := True;
DEC := DEC + (Ord(OCT[J]) - 48) shl ((Length(OCT) - J) * 3);
{ 8^N = 2^(N * 3) }
{ N SHL ((Length(OCT) - J) * 3) = N * 8^(Length(OCT) - J) }
end;
if Error then
OCT2DEC := 0
else
OCT2DEC := DEC;
end;

function BIN2HEX(BIN: string): string;

function SetHex(St: string; var Error: BOOLEAN): CHAR;

var
Ch: CHAR;

begin
if St = '0000' then
Ch := '0'
else if St = '0001' then
Ch := '1'
else if St = '0010' then
Ch := '2'
else if St = '0011' then
Ch := '3'
else if St = '0100' then
Ch := '4'
else if St = '0101' then
Ch := '5'
else if St = '0110' then
Ch := '6'
else if St = '0111' then
Ch := '7'
else if St = '1000' then
Ch := '8'
else if St = '1001' then
Ch := '9'
else if St = '1010' then
Ch := 'A'
else if St = '1011' then
Ch := 'B'
else if St = '1100' then
Ch := 'C'
else if St = '1101' then
Ch := 'D'
else if St = '1110' then
Ch := 'E'
else if St = '1111' then
Ch := 'F'
else
Error := True;
SetHex := Ch;
end;

var
HEX: string;
I: INTEGER;
Temp: string[4];
Error: BOOLEAN;

begin
Error := False;
if BIN = '0' then
HEX := '0'
else
begin
Temp := '';
HEX := '';
if Length(BIN) mod 4 < > 0 then
repeat
BIN := '0' + BIN;
until Length(BIN) mod 4 = 0;
for I := 1 to Length(BIN) do
begin
Temp := Temp + BIN[I];
if Length(Temp) = 4 then
begin
HEX := HEX + SetHex(Temp, Error);
Temp := '';
end;
end;
end;
if Error then
BIN2HEX := '0'
else
BIN2HEX := HEX;
end;

function HEX2BIN(HEX: string): string;

var
BIN: string;
I: INTEGER;
Error: BOOLEAN;

begin
Error := False;
BIN := '';
for I := 1 to Length(HEX) do
case UpCase(HEX[I]) of
'0': BIN := BIN + '0000';
'1': BIN := BIN + '0001';
'2': BIN := BIN + '0010';
'3': BIN := BIN + '0011';
'4': BIN := BIN + '0100';
'5': BIN := BIN + '0101';
'6': BIN := BIN + '0110';
'7': BIN := BIN + '0111';
'8': BIN := BIN + '1000';
'9': BIN := BIN + '1001';
'A': BIN := BIN + '1010';
'B': BIN := BIN + '1011';
'C': BIN := BIN + '1100';
'D': BIN := BIN + '1101';
'E': BIN := BIN + '1110';
'F': BIN := BIN + '1111';
else
Error := True;
end;
if Error then
HEX2BIN := '0'
else
HEX2BIN := BIN;
end;

function Potens(X, E: LONGINT): LONGINT;

var
P, I: LONGINT;

begin
P := 1;
if E = 0 then
P := 1
else
for I := 1 to E do
P := P * X;
Potens := P;
end;

function DEC2BASEN(BASE: INTEGER; DEC: LONGINT): string;

const
NUMString: string = '0123456789ABCDEFGHAIJKLMNOPQRSTUVWXYZ';

var
NUM: string;
I, J: INTEGER;

begin
if (DEC = 0) or (BASE < 2) or (BASE > 36) then
NUM := '0'
else
begin
NUM := '';
I := 0;
while Potens(BASE, I + 1) < = DEC do
I := I + 1;
for J := 0 to I do
begin
NUM := NUM + NUMString[(DEC div Potens(BASE, I - J)) + 1];
DEC := DEC mod Potens(BASE, I - J);
end;
end;
DEC2BASEN := NUM;
end;

function BASEN2DEC(BASE: INTEGER; NUM: string): LONGINT;

function Digt(Ch: CHAR): BYTE;

const
NUMString: string = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ';

var
I: BYTE;
N: BYTE;

begin
N := 0;
for I := 1 to Length(NUMString) do
if Ch = NUMString[I] then
N := I - 1;
Digt := N;
end;

const
NUMSet: set of CHAR = ['0'..'9', 'A'..'Z'];

var
J: INTEGER;
Error: BOOLEAN;
DEC: LONGINT;

begin
DEC := 0;
Error := False;
if (BASE < 2) or (BASE > 36) then
Error := True;
for J := 1 to Length(NUM) do
begin
if (not (UpCase(NUM[J]) in NUMSet)) or (BASE < Digt(NUM[J]) + 1) then
Error
:= True;
DEC := DEC + Digt(UpCase(NUM[J])) * Potens(BASE, Length(NUM) - J);
end;
if Error then
BASEN2DEC := 0
else
BASEN2DEC := DEC;
end;

end.

ПС.
Аккуратнее ставь вопросы..

 

[berkutua]

Спасиб, ребята. Кто нибудь может дать полностью исходник проги для Делфи или сам проэкт? А то я не совсем понимаю как использовать данный модуль когда создаю Апликейшн

 

[Barmutik]

Создайте чистый модуль .. вставьте туда этот текст и потмо подключите этот модуль к Вашему проекту...

 

[berkutua]

Я так понял после того, как модуль создан, его имя нужно указать(в данном случае CONVUNIT.pas) в "Uses" правильно?
Типа "uses: CONVUNIT.pas ..."
А как его использовать в самом апликейшене? Всмысле как вызвать его исполнение?
ПС Походу можно его как модуль и не использовать. Просто вставить в текст программы. Правильно?
Использую модуль, проэкт выглядит грамотно выполненым, но сперва не совсем понятным в плане работы с ним для новичков.

 

[vital]

2berkutua
Извини, но ты УВЕРЕН в выборе профессии?)

Делаешь, то что написал Barmutik, в uses формы добавляешь CONVUNIT; (т.е. uses то_что_было,CONVUNIT. И пользуешься функциями. Можно, в принципе, вставить и в сам проэкт, но лично мне не улыбается наматывать километры на мышином колесе скроля текст ничего_не_делающей формы..
2Barmutik
Не сразу я заметил что там исправлено..

 

[berkutua]

Спасиб.
Ну а что по профессии. Я не на программиста пошел) Информационная безопасность. Есть в этом конечно элементы программирования, но не в такой степени.