如何将任意长度十六进制转十进制

Posted 2023-04-30

注意整数（十六进制表示）非常大远大于8字节，有什么算法将其转换为十进制，使用C++解决
bdScan实现了这个算法，在此表示感谢
不过个人觉得太过复杂
自己想了一种算法，觉得稍微简单一些，而且可以将任意长度的任意进制转为另一种进制
#include<iostream>
using namespace std;
void main()

const int length = 50;
unsigned int a[length] = 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1; //高位在后
const int x = 10; //需要转化为的进制
const int step = 256; //原先的进制
int high = length - 1; //值不为零的最大下标 ，初始值为最大下标
while (1)

while (high >= 0)
if (a[high] != 0)break;
else high--;
if (high < 0)break;
for (int j = high;j > 0;j--)

a[j - 1] += (a[j] % x) * step;
a[j] = a[j] / x;

cout << a[0] % x << ' '; //对于每一位的输出都是十进制数表示，不同位的输出高位在后,也就是倒着输出的
a[0] /= x;

cout << endl;
getchar();

大家可以试一下

呐,按你的要求,c++的.
确实是用大数的,只写了需要用的加和乘,但是已经达到要求的把任意长16进制转化为10进制了

#include < iostream >
#include < vector >
#include < cassert >
#include < string >
#include < sstream >
using namespace std;
//具有加法和部分乘法(只能乘一个int型)的一个大数类
class LargeNum

//用整型数组存放这个大数,每个元素(int),取值为0~9999
vector<int> Num;
public:
//初始化和赋值拷贝定义
LargeNum(int in=0 ): Num(1, in )

assert(Num[0]<10000 );

LargeNum & operator= (LargeNum const &in )

Num= in.Num;
return * this;

//部分乘法定义
LargeNum const operator * (int in )const

assert(in<10000 );
LargeNum T(*this );
int carry=0, temp, i=0;
while(i!= T.Num.size( ) )

temp=T.Num[i]*in;
T.Num[i]=carry+temp%10000;
carry= temp/10000+T.Num[i]/10000;
T.Num[i++] %= 10000;

if(carry )
T.Num.push_back(carry );
return T;

LargeNum & operator *= (int in )

return *this=*this*in;

//加法定义
LargeNum const operator +(LargeNum const &in )const

const LargeNum *big=Num.size( )>in.Num.size( ) ? this:∈
const LargeNum *small=big == this ? &in:this;
LargeNum T(*big );
int carry=0;
for(int i=0; i<T.Num.size( ); i++ )

T.Num[i] += carry+
(i<small->Num.size( ) ? small->Num[i]:0 );
carry=T.Num[i]/10000;
T.Num[i] %= 10000;

if(carry )
T.Num.push_back(carry );
return T;

LargeNum & operator += (LargeNum const &in )

return *this=*this+in;

//打印
void print( )const

if(Num.size( ) )
cout << Num[Num.size( )-1];
cout.fill('0' );
for(int i=Num.size( )-2; i >= 0; i-- )

cout.width(4 );
cout << Num[i];

cout << endl;

;
//将16进制的字符串转化为大数
void HexToDec(LargeNum &in, string const &str )

in=0;
LargeNum F=1;
int start=str.size( ), n=0;
while(n++, --start >= 0 )
if(n == 3 || !start )

istringstream SIN(str.substr(start, n ) );
int temp;
SIN >> hex>> temp;
in += F*temp;
n=0;
F*=4096;


//测试
int main( )

LargeNum n;
string str;
cin>> str;
HexToDec(n, str );
n.print( );


如果不操作得到的结果的话,下面,也就是楼主的方法
将用0~9和a~z输入的2到36进制数转化为其他进制,只显示,没有定义运算

#include< iostream >
#include< string >
using namespace std;
//将字符串转化为运算量
void tran_n(string &in )

for(int i=0; i<in.size( ); i++ )

if(in[i] >= 97 )
in[i] -= 87;
else if(in[i] >= 65 )
in[i] -= 55;
else
in[i] -= 48;


//将运算量转化为字符串显示格式
void tran_c(string &in )

for(int i=0; i<in.size( ); i++ )

if(in[i] >= 10 )
in[i] += 87;
else
in[i] += 48;


void main( )

cout << "多少进制到多少进制?"<< endl;
int S, D;
cin >> S>> D;
cout << "输入转化前:"<< endl;
string Sstr, Dstr;
cin>> Sstr;
tran_n(Sstr );
//转化
while(Sstr.size( ) )

for(int i=0; i<Sstr.size( )-1; i++ )

Sstr[i+1] += (unsigned char )Sstr[i]%D*S;
Sstr[i]=(unsigned char )Sstr[i]/D;

Dstr=char((unsigned char )Sstr[Sstr.size( )-1]%D )+Dstr;
Sstr[Sstr.size( )-1]=(unsigned char )Sstr[Sstr.size( )-1]/D;
while(!Sstr[0] && Sstr.size( ) )
Sstr.erase(0, 1 );

tran_c(Dstr );
cout << "转化结果:"<< endl;
cout << Dstr;
参考技术A 难点就是大数的乘法 ，用数组来存贮一个数吧
1f2e: char a1,15,2,14
这里的1是 16^3=4096=4，0，9，6
过程 16*16=1,6*16=1*16,16*6=16,96=16+9,6=0+2,5,6

数组的长度也是可预测的，假设16进制数长n位，则涉及的运算位不超过2*n位
(肯定不是最接近的，因为 2*n位是 100进制数的长度，这个自己衡量吧)

输出不是非常easy了？
数组 int yourint[1000]存了iCount位的运算结果,运算时肯定要保留运算长度
for(int i=iCount;i;i--)

printf("%d",yourint[i]);

我知道你这个问题的提出是习惯问题，因为数位从低向高的顺序是从右向左的，正好相反。
解决问题的思路就是对问题的主要特点都整理清楚，分析问题是首位的，至于怎么去解决他反而可谓是次要的了
输出来就可以了 参考技术B 这个问题的难度就是十进制大数的运算，十六进制是不是字符串都没关系，因为只要从高位到低位一位一位处理，但中间十进制的结果一定很大，基本算法想必牛人你也知道，下面的例子表明关键还是大数的加法，如何将_big用大数组或链表或字符串等方法表示。
综上所述，这个问题实际上只涉及到单纯的大数加法。

char _hex[1000]="f1092fac001321bc120c0001010000000000000000000101";
int _big=0;//十进制大数
const int step = 16;
for(int i=0; _hex[i]!=0; i++)

if(_hex[i]>='a'&&_hex[i]<='z')
_big += step * (_hex[i]-'a'+9);

if(_hex[i]>='A'&&_hex[i]<='Z')
_big += step * (_hex[i]-'A'+9);

if(hex[i]>='0'&&_hex[i]<='9')
_big += step * (_hex[i]-'0'）;//将_big和+操作转化为大数操就行
参考技术C 既然远大于8字节,那么你也没法用整型变量来放十进制的结果啊.所以肯定要用数组来模拟大数.具体到此题,你至少要实现大数的加法和乘法.楼主可以尝试着去模拟一下手工计算大数的四则运算的过程,对提高编程能力很有帮助. 参考技术D 那是VB,你什么语言也没说,如果是C语言可以直接进行输出格式控制,
而你都说以8字节装一个远大于8字节的整数（十六进制表示）,我个人觉得不行,可能我不会吧.

python 数值转BCD，如何拼接二进制字符串

今天工作中遇到python数值转换为BCD编码的问题。公司现有C语言的动态库实现了特定的BCD压缩但是并不通用。如 20160701转换成BCD后为 02 01 60 70 1F，即前补0后补F多出了一个字节。
由于第三方要求(通用的)是8位的日期转换成的是4个字节的BCD值即，20160102在内存中是长度为4字节的'\x20\x16\x01\x02'。怎么整！怎么整！！！！！

实现方式1（失败求帮助）：
Python 有bytes=struct.pack('i',1),bytes实际是字符串，1的16进制表示为'\x01\x00\x00\x00'。基于该功能，想通过类似于操作数组的形式bytes[0]='\x20'
bytes[1]='\x16'......
但是修改bytes[index]里面的值会报错（TypeError: 'str' object does not support item assignment），字节编码值不能进行类似操作。

实现方式2（失败求帮助）
方式2是直接采用字符串与\x拼接。如 '\x' + str。这时报错（ValueError: invalid \x escape）。
将\x中的斜杠转译 \\x倒是可以与字符串拼接。但是却改变了原本的数值。

综上所述：1.如何操作bytes像数组一样。
2.如何拼接字节字符串，即方式2中所希望的拼接方式。
这些都不行，有没有更为精准实际的办法。

首先你可以自己写函数采用%2的方式来算.
但是python自带了方法 bin.
比如bin(12345)回返回字符串\'0b11000000111001\' 这个时候在把0b去掉即可.
bin(number).replace(\'0b\',\'\') 参考技术A 举个例子
连接数据库查询表的相关语句：
Class.forName("com.microsoft.jdbc.sqlserver.SQLServerDriver");
Connection conn=DriverManager.getConnection("jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=mytest","sa","123");
Statement stmt=conn.createStatement();
ResultSet rs=stmt.executeQuery("select * from userinfo");
while(rs.next())追问

给你个眼神