c语言进制转换:C任意进制转换程序

以前做C培训时写个任意进制转换不使用库提供转换现贴出来做下记录

/ scale.cpp : 定义控制台应用入口点
//

# "stdafx.h"
# <stdio.h>
# <stdlib.h>
# <ctype.h>
# <.h>
# <math.h>

# WIDTH 10
# DATAWIDTH 50
# MAX 4294967295
# CONST_2 2
# CONST_3 3
# CONST_8 8
# CONST_9 9
# CONST_10 10
# CONST_16 16
# CHAR_0 '0'
# CHAR_9 '9'
# CHAR_A 'A'
# CHAR_a 'a'
# CHAR_Z 'Z'
# CHAR_SPACE ' '
# STRING_0 "0"
# STRING_Z "Z"

bool Scale;
bool GetSourceScale( * scale_in);
bool GetObjectScale( * scale_out);
double OtherToDeci( scale_in,char inputdata);
void DeciToOther(unsigned long deci, scale_out,char outputdata);
bool GetData(char data, CONCOUNT, flg);
bool GetScale(char temp);
bool GetSource( in_scale,char inputdata);
void ScaleChange( scale_in,char inputdata, scale_out,char outputdata);
void CleanScreen;

_t( argc, _TCHAR* argv)
{

flg = 0;
char cs[WIDTH];

mem(cs,0x00,(cs));

while(1)
{
prf("-----------------------------------------------------------------\n");
prf(" Data Transform Between Two Scales \n");
prf(" ----------------------------------------\n");

/*进制转换主*/
(!Scale)
{
;
}

prf("-----------------------------------------------------------------\n");
prf("input any key and press 'Enter' key to continue, 'Z' for exit:");
(!GetData(cs,WIDTH,flg)) /*判断是否继续执行下次转换*/
{
;
}
system("cls"); /*清屏*/
}

0;
}

bool Scale
{
scale_in,scale_out;
char inputdata[DATAWIDTH];
char outputdata[DATAWIDTH];

/*输入源数据进制*/
(!GetSourceScale(&scale_in))
{
false;
}

/*输入源数据*/
(!GetSource(scale_in,inputdata))
{
false;
}

/*输入目标数据进制*/
(!GetObjectScale(&scale_out))
{
false;
}

/*进行进制转换*/
ScaleChange(scale_in,inputdata,scale_out,outputdata);

true;
}

bool GetSourceScale( * scale_in) /*输入源数据进制*/
{
char temp.gif' />[WIDTH];

mem(temp.gif' />,0x00,(temp.gif' />));

prf("Input source data scale and press 'Enter' key(one of 2,8,10,16. 'Z' for exit): \n");
(!GetScale(temp.gif' />))
{
false;
}
*scale_in = atoi(temp.gif' />);

true;
}

bool GetObjectScale( * scale_out) /*输入目标数据进制*/
{
char temp.gif' />[WIDTH];

mem(temp.gif' />,0x00,(temp.gif' />));

prf("Input object data scale and press 'Enter' key(one of 2,8,10,16. 'Z' for exit): \n");
(!GetScale(temp.gif' />))
{
false;
}
*scale_out = atoi(temp.gif' />);

true;
}

bool GetData(char data, CONCOUNT, flg) /*输入数据*/
{
i,icount;
char c;
char *p;
bool spaceFlag;

i = 0;
icount = 0;
spaceFlag = true;
while ((c = getchar) != 0x0a)
{
(spaceFlag && c CHAR_SPACE) /*去掉前空格*/
{
continue;
}

(!spaceFlag && c CHAR_SPACE) /*去掉后空格*/
{
icount;
continue;
}
(icount > 0)
{
(flg)
{
CleanScreen;
prf("ERROR! Please input again('Z' for exit): \n"); /*输入进制或者源数据时中间有空格则重新输入*/
i = 0;
icount = 0;
spaceFlag = true;
fflush(stdin);
continue;
}

{
;
}
}

(i CONCOUNT - 1) /*判断是否输入数据过长*/
{
(flg)
{
CleanScreen;
prf("ERROR! Too many characters.Please input again('Z' for exit): \n");
mem(data,0x00,(data));
fflush(stdin);
i = 0;
continue;
}

{
;
}
}

(c CHAR_0 && !strcmp(data,STRING_0))
{
continue;
}

data[i] = c;
i;
spaceFlag = false;
}

data[i] = '\0';

p = data;
(*p CHAR_0 && strlen(p) > 1)
{
p;
}
strcpy(data,p);

(strlen(data) && !strcmp(data,STRING_Z))
{
false;
}
true;
}

/*输入数据进制*/
bool GetScale(char temp)
{
i,num,kbn_flg;
char scalewidth[WIDTH];
char * s;
bool flag;

kbn_flg = 1;
flag = false;

while (!flag)
{
mem(scalewidth,0x00,(scalewidth));
mem(temp,0x00,(temp));

(!GetData(scalewidth,WIDTH,kbn_flg)) /*输入数据*/
{
false;
}
s = scalewidth;

(!strlen(s)) /*判断是否输入数据*/
{
CleanScreen;
prf("ERROR! Please input the scale(one of 2,8,10,16. 'Z' for exit): \n");
continue;
}

i = 0;
while (*s)
{
(*s >= CHAR_0 && *s <= CHAR_9) /*判断是否输入整数*/
{
temp[i] = *s;
i;
s;
flag = true;
}

{
CleanScreen;
prf("ERROR! Please input the scale(one of 2,8,10,16. 'Z' for exit): \n");
flag = false;
;
}
}
temp[i] = '\0';

num = 0;
(flag)
{
num = atoi(temp);
(!(num CONST_2 || num CONST_8 || num CONST_10 || num CONST_16)) /*判断是否输入合法整数*/
{
CleanScreen;
prf("ERROR! Please input the scale(one of 2,8,10,16. 'Z' for exit): \n");
flag = false;
}
}
}
true;
}

/*输入源数据*/
bool GetSource( in_scale,char inputdata)
{
i,kbn_flg;
char * s;
char sourcedata[DATAWIDTH];
bool flag;

kbn_flg = 1;
flag = false;

prf("Please input _disibledevent=>
(!strlen(s)) /*判断是否输入数据*/
{
CleanScreen;
prf("ERROR! The input is not available!Please input again('Z' for exit): \n");
continue;
}

i = 0;
while(*s) /*判断是否输入合法数据*/
{
((in_scale >= CONST_2 && in_scale <= CONST_10) && ( CHAR_0 <= *s && *s < in_scale + CHAR_0))
{
inputdata[i] = *s;
i;
s;
flag = true;
}
((in_scale CONST_16)
&& ((CHAR_0 <= *s && *s <= CHAR_9)
|| (CHAR_A <= *s && *s <= in_scale + CHAR_A - CONST_10 - 1)
|| (CHAR_a <= *s && *s <= in_scale + CHAR_a - CONST_10 - 1)))
{
inputdata[i] = *s;
i;
s;
flag = true;
}

{
CleanScreen;
prf("ERROR! The input is not available!Please input again('Z' for exit):\n");
flag = false;
;
}
}
inputdata[i] = '\0';

(OtherToDeci(in_scale,inputdata) > (double)MAX)
{
CleanScreen;
prf("ERROR! The input is not available!Please input again(less than ");
switch (in_scale)
{
CONST_2: prf("32 bits 1.");
;
CONST_8: prf("37777777777.");
;
CONST_10:prf("4294967295.");
;
CONST_16:prf("8 bits F or f.");
;
}
prf(" 'Z' for exit): \n");
flag = false;
continue;
}
}
true;
}

/*其他进制转换为十进制*/
double OtherToDeci( scale_in,char inputdata)
{
i,len,mid;
double middbl,temp;

len = strlen(inputdata);
temp = 0.00;

for(i = 0;i < len; i)
{
mid = inputdata[i];

( CHAR_0 <= mid && mid <= CHAR_9 )
{
mid = mid - CHAR_0; /*0-9*/
}
( CHAR_A <= mid && mid <= CHAR_Z )
{
mid = mid - CHAR_A + CONST_10; /*A-Z*/
}

{
mid = mid - CHAR_a + CONST_10; /*a-z*/
}

middbl = mid * pow(scale_in,len-i-1);
temp = temp + middbl;
}
temp;
}

/*十进制转换为其他进制*/
void DeciToOther(unsigned long deci, scale_out,char outputdata)
{
m,n;

m = 0;
n = 0;

while (deci)
{
m = deci % scale_out;
(m > CONST_9)
{
outputdata[n] = m + CHAR_A - CONST_10;
}

{
outputdata[n] = m + CHAR_0;
}
deci = deci / scale_out;
n;
}

for (m = 0; m <= n / 2 - 1; m) /*反序得到目标数据*/
{
char t;
t = outputdata[m];
outputdata[m] = outputdata[n - 1 - m];
outputdata[n - 1 - m] = t;
}
outputdata[n] = '\0';
}

void PutSource(char inputdata) /*输出源数据*/
{
k;
(!strcmp(inputdata,STRING_0)) /*源数据为0*/
{
prf("(The source data is: 0)\n");
}

{
prf("(The source data is: ");
for( k = 0; k < strlen(inputdata); k )
{
prf("%c",inputdata[k]);
}
prf(")\n");
}
}

void ScaleChange( scale_in,char inputdata, scale_out,char outputdata) /*进制转换*/
{
k;
unsigned long deci;

deci = 0;

(scale_in scale_out) /*原数据进制和目标数据进制相同,不用转换 */
{
(!strcmp(inputdata,STRING_0))
{
prf("The object data is: \n0\n");
}

{
prf("The object data is: \n");
for( k = 0; k < strlen(inputdata); k )
{
prf("%c",inputdata[k]);
}
prf("\n");
}
PutSource(inputdata);
}

{
(scale_in CONST_10)
{
deci = atol(inputdata); /*源数据是十进制直接转换为十进制数*/
}

{
deci = (unsigned long)OtherToDeci(scale_in,inputdata); /*其他进制转换为十进制*/
}

(scale_out CONST_10) /*如果目标进制是十进制直接输出十进制数*/
{
prf("The object data is: \n%u \n",deci);
}

{
(!deci) /*源数据为0*/
{
prf("The object data is: \n0\n");
}

{
DeciToOther(deci,scale_out,outputdata); /*十进制转换为其他进制*/

prf("The object data is: \n"); /*输出转换后结果*/
for( k = 0; k < strlen(outputdata); k )
{
prf("%c",outputdata[k]);
}
prf("\n");
}
}
PutSource(inputdata);
}
}

void CleanScreen /*清屏*/
{
errcount = 0;
errcount;
(!(errcount % CONST_3))
{
errcount = 0;
system("cls");
}
}

延伸阅读

• 2011-6-14-- 二进制文件转换,二进制文件图形转换工具
• 2011-4-16-- 字符转换二进制,把图象文件转换成XML格式文件（二进制转字符）
• 2010-12-9-- 各种进制转换,asp.net（c#）下各种进制间的轻松转换（2进制、8进制、10进制、16进制）
• 2008-11-29-- vb进制转换:VB 进制转换教程
• 2008-11-29-- 2进制转换:进制转换详解2
• 2009-9-12-- c语言十六进制:十 6进制代码转换器 C语言
• 2010-12-1-- 进制转换,将一个数从M进制转换成N进制
• 2009-2-12-- 二进制:探讨二进制兼容性
• 2009-8-16-- 数据库存储图片:将图片转换成 2进制存储在数据库中
• 2009-1-9-- 进制转换c语言:C#进制转换的记录