求十六进制转十进制

2014-05-05 08:38:46 341 阅读 AI 写同款 · GEO 优化AI 选题数据监测一键分发 ›

二进制，八进制，十进制，十六进制的概念及相互转换里面需要注意的就是其他进制转化十进制都是需要按权展开来求的，整数权位从个位为0开始，小数部分都是-1开始，十进制转换其他进制都是整数求余，小数求整，最后反向排序结合就可以了，然后就是二，八，十六进制直接需要二进制来对应三对一，四对一，相对还是很简单的。这里没有基础的人可能有人疑惑最后一步1除以2，怎么等于0余1呢，这里是这样，在进制除法中，只要除以一个数，等于0的时候，直接余那个数就可以了，因为反向排列，他的权位等于0，那么这个值在计算时他的值就等于本身。只有0，1，2，3，4，5，6，7。阅读详情

求快速将一千位以上十六进制大整数快速转换十进制数的算法……其实我是想把它以十进制数字字符串的形式打印出来。

...全文

【C语言/java基础】二进制，八进制，十进制，十六进制的进制转化。原码，反码，补码，以及之间的转换。十进制转其他进制。任意进制之间的转换，原码，反码，补码，以及之间的转换进制转化，二进制，八进制，十进制，十六进制。原码，反码，补码，以及之间的转换十进制转其他进制。任意进制之间的转换。阅读详情

lyramilk

C++ 语言 65,214 成员 250,514 内容

+ 关注 + 加入社区

切换为时间正序

lm_whales 2014-05-09

打赏
举报

引用 23 楼 lyramilk 的回复:

在这个方法上我又作了一些优化，最后终于优化到debug 2秒，release瞬间完成的程度了。我也想到了一些其它的优化方法，不过暂时不需要讨论了，有这个效率我想是可以接受的了。结帖。

恭喜

lyramilk 2014-05-09

打赏
举报

引用 22 楼 lm_whales 的回复:

[quote=引用 21 楼 lyramilk 的回复:] 感谢大家，尤其是lm_whales的帮助，确实除法次数虽然不可避免，但可以减少每一次除法所需要处理数据的量。这个办法己经可以把我的计算从8分多减少到19秒了。

这只是个笨办法，也许还有许多精妙的办法。我原来考虑是用查表的，只是不知道能不能做到。我自己没有想通，所以，就换了这个一定可行的办法从算法上来说，并没多少该进，就像冒泡排序，和插入排序，差别不大还是二次的，只是改进的规模比较大一点我想一定还有更好的。 [/quote] 在这个方法上我又作了一些优化，最后终于优化到debug 2秒，release瞬间完成的程度了。我也想到了一些其它的优化方法，不过暂时不需要讨论了，有这个效率我想是可以接受的了。结帖。

蠓虫带着秤砣飞 2014-05-06

打赏
举报

这个，用加权系数法转换就好了。

gz_qmc 2014-05-06

打赏
举报

我来谈谈我的思路，仅供参考假设16进制字串有4096个字符吧那么在32位机器上建立4096/4=1024个字串表示各段位的10进制数比如：000000010000000A............ 则可简单得到x[0]="1";x[2]="12"................... 那么显而易见最后10进制数的结果就是 n=((((x[0]*16)+x[1])*16)+x[2])*16........+x[1022])*16+x[1023]; 所以，建立两函数就可以函数1：10进制字串相加 char *Add(char *d1,char *d2); 函数2：10进制字串*16 char *Mul16(char *d); 于是实现就变成 y=Mul16(x[0]); for(int i=1;i<1023;i++) { y=Add(y,x[i]); y=Mul16(y); } y=Add(y,x[1023]);

lm_whales 2014-05-06

打赏
举报

引用 21 楼 lyramilk 的回复:

感谢大家，尤其是lm_whales的帮助，确实除法次数虽然不可避免，但可以减少每一次除法所需要处理数据的量。这个办法己经可以把我的计算从8分多减少到19秒了。

这只是个笨办法，也许还有许多精妙的办法。我原来考虑是用查表的，只是不知道能不能做到。我自己没有想通，所以，就换了这个一定可行的办法从算法上来说，并没多少该进，就像冒泡排序，和插入排序，差别不大还是二次的，只是改进的规模比较大一点我想一定还有更好的。

lyramilk 2014-05-06

打赏
举报

感谢大家，尤其是lm_whales的帮助，确实除法次数虽然不可避免，但可以减少每一次除法所需要处理数据的量。这个办法己经可以把我的计算从8分多减少到19秒了。

lyramilk 2014-05-06

打赏
举报

引用 12 楼 PDD123 的回复:

建议你把大数换个方式表示。换成直接能计算那种。比如把一个双字（4个字节）当成是一位，然后把一个无符号整形数组当成是4294967296进制的数，或许再加一个字节表示符号。这样计算起来应该更快一点。

引用 15 楼 lm_whales 的回复:

100000000进制或者1000000000进制

我改用分段除，确实速度快了不少。旧代码


    xint k = r;

    std::stringstream ss;
    while(k > 0){
        xint v = k%10;
        k /= 10;
        unsigned int p = v.d.empty()?0:v.d.front();
        ss << p;
    }

新代码


xint k = r;

    std::stringstream ss;
    while(k > 0){
        xint v = k%1000000000000000;
        k /= 1000000000000000;
        while(v > 0){
            xint m = v%10;
            v /= 10;
            unsigned int p = m.d.empty()?0:m.d.front();
            ss << p;
        }
    }

lyramilk 2014-05-06

打赏
举报

引用 13 楼 zhao4zhong1 的回复:

搜“DAS 减法的十进制调整”

用BCD码确实是一个不错的想法。。。。

lyramilk 2014-05-05

打赏
举报

引用 8 楼 zhao4zhong1 的回复:

#include <iostream>
#include <string>
using namespace std;
inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1
         if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数
    else if (str1.size()<str2.size()) return -1;
    else                              return str1.compare(str2); //若长度相等，则头到尾按位比较
}
string SUB_INT(string str1,string str2);
string ADD_INT(string str1,string str2) {//高精度加法
    int sign=1; //sign 为符号位
    string str;
    if (str1[0]=='-') {
        if (str2[0]=='-') {
            sign=-1;
            str=ADD_INT(str1.erase(0,1),str2.erase(0,1));
        } else {
            str=SUB_INT(str2,str1.erase(0,1));
        }
    } else {
        if (str2[0]=='-') {
            str=SUB_INT(str1,str2.erase(0,1));
        } else { //把两个整数对齐，短整数前面加0补齐
            string::size_type L1,L2;
            int i;
            L1=str1.size();
            L2=str2.size();
            if (L1<L2) {
                for (i=1;i<=L2-L1;i++) str1="0"+str1;
            } else {
                for (i=1;i<=L1-L2;i++) str2="0"+str2;
            }
            int int1=0,int2=0; //int2 记录进位
            for (i=str1.size()-1;i>=0;i--) {
                int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;
                int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;
                str=char(int1+'0')+str;
            }
            if (int2!=0) str=char(int2+'0')+str;
        }
    }
    //运算后处理符号位
    if ((sign==-1)&&(str[0]!='0')) str="-"+str;
    return str;
}
string SUB_INT(string str1,string str2) {//高精度减法
    int sign=1; //sign 为符号位
    string str;
    int i,j;
    if (str2[0]=='-') {
        str=ADD_INT(str1,str2.erase(0,1));
    } else {
        int res=compare(str1,str2);
        if (res==0) return "0";
        if (res<0) {
            sign=-1;
            string temp =str1;
            str1=str2;
            str2=temp;
        }
        string::size_type tempint;
        tempint=str1.size()-str2.size();
        for (i=str2.size()-1;i>=0;i--) {
            if (str1[i+tempint]<str2[i]) {
                j=1;
                while (1) {//zhao4zhong1添加
                    if (str1[i+tempint-j]=='0') {
                        str1[i+tempint-j]='9';
                        j++;
                    } else {
                        str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);
                        break;
                    }
                }
                str=char(str1[i+tempint]-str2[i]+':')+str;
            } else {
                str=char(str1[i+tempint]-str2[i]+'0')+str;
            }
        }
        for (i=tempint-1;i>=0;i--) str=str1[i]+str;
    }
    //去除结果中多余的前导0
    str.erase(0,str.find_first_not_of('0'));
    if (str.empty()) str="0";
    if ((sign==-1) && (str[0]!='0')) str ="-"+str;
    return str;
}
string MUL_INT(string str1,string str2) {//高精度乘法
    int sign=1; //sign 为符号位
    string str;
    if (str1[0]=='-') {
        sign*=-1;
        str1 =str1.erase(0,1);
    }
    if (str2[0]=='-') {
        sign*=-1;
        str2 =str2.erase(0,1);
    }
    int i,j;
    string::size_type L1,L2;
    L1=str1.size();
    L2=str2.size();
    for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式
        string tempstr;
        int int1=0,int2=0,int3=int(str2[i])-'0';
        if (int3!=0) {
            for (j=1;j<=(int)(L2-1-i);j++) tempstr="0"+tempstr;
            for (j=L1-1;j>=0;j--) {
                int1=(int3*(int(str1[j])-'0')+int2)%10;
                int2=(int3*(int(str1[j])-'0')+int2)/10;
                tempstr=char(int1+'0')+tempstr;
            }
            if (int2!=0) tempstr=char(int2+'0')+tempstr;
        }
        str=ADD_INT(str,tempstr);
    }
    //去除结果中的前导0
    str.erase(0,str.find_first_not_of('0'));
    if (str.empty()) str="0";
    if ((sign==-1) && (str[0]!='0')) str="-"+str;
    return str;
}
string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商; flag==0时,返回余数
    string quotient,residue; //定义商和余数
    int sign1=1,sign2=1;
    if (str2 == "0") {  //判断除数是否为0
        quotient= "ERROR!";
        residue = "ERROR!";
        if (flag==1) return quotient;
        else         return residue ;
    }
    if (str1=="0") { //判断被除数是否为0
        quotient="0";
        residue ="0";
    }
    if (str1[0]=='-') {
        str1   = str1.erase(0,1);
        sign1 *= -1;
        sign2  = -1;
    }
    if (str2[0]=='-') {
        str2   = str2.erase(0,1);
        sign1 *= -1;
    }
    int res=compare(str1,str2);
    if (res<0) {
        quotient="0";
        residue =str1;
    } else if (res == 0) {
        quotient="1";
        residue ="0";
    } else {
        string::size_type L1,L2;
        L1=str1.size();
        L2=str2.size();
        string tempstr;
        tempstr.append(str1,0,L2-1);
        for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式
            tempstr=tempstr+str1[i];
            tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加
            if (tempstr.empty()) tempstr="0";//zhao4zhong1添加
            for (char ch='9';ch>='0';ch--) { //试商
                string str;
                str=str+ch;
                if (compare(MUL_INT(str2,str),tempstr)<=0) {
                    quotient=quotient+ch;
                    tempstr =SUB_INT(tempstr,MUL_INT(str2,str));
                    break;
                }
            }
        }
        residue=tempstr;
    }
    //去除结果中的前导0
    quotient.erase(0,quotient.find_first_not_of('0'));
    if (quotient.empty()) quotient="0";
    if ((sign1==-1)&&(quotient[0]!='0')) quotient="-"+quotient;
    if ((sign2==-1)&&(residue [0]!='0')) residue ="-"+residue ;
    if (flag==1) return quotient;
    else         return residue ;
}
string DIV_INT(string str1,string str2) {//高精度除法,返回商
    return DIVIDE_INT(str1,str2,1);
}
string MOD_INT(string str1,string str2) {//高精度除法,返回余数
    return DIVIDE_INT(str1,str2,0);
}
int main() {
    char ch;
    string s1,s2,res;

    while (cin>>s1>>ch>>s2) {
        switch (ch) {
            case '+':res=ADD_INT(s1,s2);break;
            case '-':res=SUB_INT(s1,s2);break;
            case '*':res=MUL_INT(s1,s2);break;
            case '/':res=DIV_INT(s1,s2);break;
            case '%':res=MOD_INT(s1,s2);break;
            default :                   break;
        }
        cout<<res<<endl;
    }
    return(0);
}

我的大整数不是字符串表示的，而是用字节数组的形式，格式和普通的int一样，只不过长度大而己，并且也是小端。计算上还好，用传统的除十取余转十进制然打再输出成字符串就太慢了。

lyramilk 2014-05-05

打赏
举报

引用 1 楼 areful 的回复:

给个思路,先整成字符串,然后自己解析

引用 6 楼 PDD123 的回复:

你的大整数应该是以十六进制字符串输入的吧？ 1.你要了解超过8字节的大数可以用什么方法（可直接计算的方法）来表示，然后把字符串转成合适的格式的大数 2.把这个大数转成十进制格式的字符串。我百度了一下itoa函数的资料，好像其算法也是求余，算出末尾，然后除10，一直循环……这样算出来的。估计这是最快的方法了。

我的大整数是计算得到的结果，以十六进制形式打印成字符串很容易，但是想打印十进制就很晕了。我用除10取余的方法，算个2的1000次方都要算小十分钟，时间全在除10取余这个过程上。所以我想知道是不是有可以遍历常数次就可以得到结果的办法。

赵4老师 2014-05-05

打赏
举报

#include <iostream>
#include <string>
using namespace std;
inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1
         if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数
    else if (str1.size()<str2.size()) return -1;
    else                              return str1.compare(str2); //若长度相等，则头到尾按位比较
}
string SUB_INT(string str1,string str2);
string ADD_INT(string str1,string str2) {//高精度加法
    int sign=1; //sign 为符号位
    string str;
    if (str1[0]=='-') {
        if (str2[0]=='-') {
            sign=-1;
            str=ADD_INT(str1.erase(0,1),str2.erase(0,1));
        } else {
            str=SUB_INT(str2,str1.erase(0,1));
        }
    } else {
        if (str2[0]=='-') {
            str=SUB_INT(str1,str2.erase(0,1));
        } else { //把两个整数对齐，短整数前面加0补齐
            string::size_type L1,L2;
            int i;
            L1=str1.size();
            L2=str2.size();
            if (L1<L2) {
                for (i=1;i<=L2-L1;i++) str1="0"+str1;
            } else {
                for (i=1;i<=L1-L2;i++) str2="0"+str2;
            }
            int int1=0,int2=0; //int2 记录进位
            for (i=str1.size()-1;i>=0;i--) {
                int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;
                int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;
                str=char(int1+'0')+str;
            }
            if (int2!=0) str=char(int2+'0')+str;
        }
    }
    //运算后处理符号位
    if ((sign==-1)&&(str[0]!='0')) str="-"+str;
    return str;
}
string SUB_INT(string str1,string str2) {//高精度减法
    int sign=1; //sign 为符号位
    string str;
    int i,j;
    if (str2[0]=='-') {
        str=ADD_INT(str1,str2.erase(0,1));
    } else {
        int res=compare(str1,str2);
        if (res==0) return "0";
        if (res<0) {
            sign=-1;
            string temp =str1;
            str1=str2;
            str2=temp;
        }
        string::size_type tempint;
        tempint=str1.size()-str2.size();
        for (i=str2.size()-1;i>=0;i--) {
            if (str1[i+tempint]<str2[i]) {
                j=1;
                while (1) {//zhao4zhong1添加
                    if (str1[i+tempint-j]=='0') {
                        str1[i+tempint-j]='9';
                        j++;
                    } else {
                        str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);
                        break;
                    }
                }
                str=char(str1[i+tempint]-str2[i]+':')+str;
            } else {
                str=char(str1[i+tempint]-str2[i]+'0')+str;
            }
        }
        for (i=tempint-1;i>=0;i--) str=str1[i]+str;
    }
    //去除结果中多余的前导0
    str.erase(0,str.find_first_not_of('0'));
    if (str.empty()) str="0";
    if ((sign==-1) && (str[0]!='0')) str ="-"+str;
    return str;
}
string MUL_INT(string str1,string str2) {//高精度乘法
    int sign=1; //sign 为符号位
    string str;
    if (str1[0]=='-') {
        sign*=-1;
        str1 =str1.erase(0,1);
    }
    if (str2[0]=='-') {
        sign*=-1;
        str2 =str2.erase(0,1);
    }
    int i,j;
    string::size_type L1,L2;
    L1=str1.size();
    L2=str2.size();
    for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式
        string tempstr;
        int int1=0,int2=0,int3=int(str2[i])-'0';
        if (int3!=0) {
            for (j=1;j<=(int)(L2-1-i);j++) tempstr="0"+tempstr;
            for (j=L1-1;j>=0;j--) {
                int1=(int3*(int(str1[j])-'0')+int2)%10;
                int2=(int3*(int(str1[j])-'0')+int2)/10;
                tempstr=char(int1+'0')+tempstr;
            }
            if (int2!=0) tempstr=char(int2+'0')+tempstr;
        }
        str=ADD_INT(str,tempstr);
    }
    //去除结果中的前导0
    str.erase(0,str.find_first_not_of('0'));
    if (str.empty()) str="0";
    if ((sign==-1) && (str[0]!='0')) str="-"+str;
    return str;
}
string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商; flag==0时,返回余数
    string quotient,residue; //定义商和余数
    int sign1=1,sign2=1;
    if (str2 == "0") {  //判断除数是否为0
        quotient= "ERROR!";
        residue = "ERROR!";
        if (flag==1) return quotient;
        else         return residue ;
    }
    if (str1=="0") { //判断被除数是否为0
        quotient="0";
        residue ="0";
    }
    if (str1[0]=='-') {
        str1   = str1.erase(0,1);
        sign1 *= -1;
        sign2  = -1;
    }
    if (str2[0]=='-') {
        str2   = str2.erase(0,1);
        sign1 *= -1;
    }
    int res=compare(str1,str2);
    if (res<0) {
        quotient="0";
        residue =str1;
    } else if (res == 0) {
        quotient="1";
        residue ="0";
    } else {
        string::size_type L1,L2;
        L1=str1.size();
        L2=str2.size();
        string tempstr;
        tempstr.append(str1,0,L2-1);
        for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式
            tempstr=tempstr+str1[i];
            tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加
            if (tempstr.empty()) tempstr="0";//zhao4zhong1添加
            for (char ch='9';ch>='0';ch--) { //试商
                string str;
                str=str+ch;
                if (compare(MUL_INT(str2,str),tempstr)<=0) {
                    quotient=quotient+ch;
                    tempstr =SUB_INT(tempstr,MUL_INT(str2,str));
                    break;
                }
            }
        }
        residue=tempstr;
    }
    //去除结果中的前导0
    quotient.erase(0,quotient.find_first_not_of('0'));
    if (quotient.empty()) quotient="0";
    if ((sign1==-1)&&(quotient[0]!='0')) quotient="-"+quotient;
    if ((sign2==-1)&&(residue [0]!='0')) residue ="-"+residue ;
    if (flag==1) return quotient;
    else         return residue ;
}
string DIV_INT(string str1,string str2) {//高精度除法,返回商
    return DIVIDE_INT(str1,str2,1);
}
string MOD_INT(string str1,string str2) {//高精度除法,返回余数
    return DIVIDE_INT(str1,str2,0);
}
int main() {
    char ch;
    string s1,s2,res;

    while (cin>>s1>>ch>>s2) {
        switch (ch) {
            case '+':res=ADD_INT(s1,s2);break;
            case '-':res=SUB_INT(s1,s2);break;
            case '*':res=MUL_INT(s1,s2);break;
            case '/':res=DIV_INT(s1,s2);break;
            case '%':res=MOD_INT(s1,s2);break;
            default :                   break;
        }
        cout<<res<<endl;
    }
    return(0);
}

赵4老师 2014-05-05

打赏
举报

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <locale.h>
int main() {
    int i,v;
    char bs[33];
    char b[33];
    char hs[9];
    char h[9];
    char s[4];
    char *e;

// 十进制整数转二进制串；
    i=1024;
    ltoa(i,b,2);
    sprintf(bs,"%032s",b);
    printf("i=%d,bs=%s\n",i,bs);
// 十进制整数转十六进制串；
    i=1024;
    ltoa(i,h,16);
    sprintf(hs,"%08s",h);
    printf("i=%d,hs=%s\n",i,hs);
// 十六进制字符串转成十进制数
    strcpy(hs,"00000400");
    sscanf(hs,"%x",&i);
    printf("hs=%s,i=%d\n",hs,i);
// 二进制字符串转化为十六进制字符串；
    strcpy(bs,"00000000000000000000010000000000");
    i=strtol(bs,&e,2);
    ltoa(i,h,16);
    sprintf(hs,"%08s",h);
    printf("bs=%s,hs=%s\n",bs,hs);
// 二进制字符串转化为十进制数；
    strcpy(bs,"00000000000000000000010000000000");
    i=strtol(bs,&e,2);
    printf("bs=%s,i=%d\n",bs,i);
// 十六进制字符串转成二进制串
    strcpy(hs,"00000400");
    sscanf(hs,"%x",&i);
    ltoa(i,b,2);
    sprintf(bs,"%032s",b);
    printf("hs=%s,bs=%s\n",hs,bs);
// ASC\GBK字符串转十六进制串
    strcpy(s,"a汉");
    i=0;
    while (1) {
        if (0==s[i]) break;
        sprintf(hs+i*2,"%02X",(unsigned char)s[i]);
        i++;
    }
    setlocale(LC_ALL,"chs");
    printf("s=%s,hs=%s\n",s,hs);
// 十六进制字符串转成汉字（GBK）及字符(ASC)
    strcpy(hs,"61BABA");
    i=0;
    while (1) {
        if (1!=sscanf(hs+i*2,"%2x",&v)) break;
        s[i]=(char)v;
        i++;
    }
    s[i]=0;
    printf("hs=%s,s=%s\n",hs,s);

    return 0;

}
//i=1024,bs=00000000000000000000010000000000
//i=1024,hs=00000400
//hs=00000400,i=1024
//bs=00000000000000000000010000000000,hs=00000400
//bs=00000000000000000000010000000000,i=1024
//hs=00000400,bs=00000000000000000000010000000000
//s=a汉,hs=61BABA
//hs=61BABA,s=a汉

lm_whales 2014-05-05

打赏
举报

32Bits一千位以上十六进制共1000/8 =125 个整数大约做不到125*125或者更少次除法，可以计算出1000000000进制数直接输出1000000000进制数，转换的除法大约9* K次除以10 操作 K表示1000000000进制数的位数

PDD123 2014-05-05

打赏
举报

你的大整数应该是以十六进制字符串输入的吧？ 1.你要了解超过8字节的大数可以用什么方法（可直接计算的方法）来表示，然后把字符串转成合适的格式的大数 2.把这个大数转成十进制格式的字符串。我百度了一下itoa函数的资料，好像其算法也是求余，算出末尾，然后除10，一直循环……这样算出来的。估计这是最快的方法了。

lm_whales 2014-05-05

打赏
举报

100000000进制或者1000000000进制

lm_whales 2014-05-05

打赏
举报

16进制32Bits存储先转换成100000000进制整数，然后输出除法用64Bits计算，，，差不多不用考虑溢出问题

mujiok2003 2014-05-05

打赏
举报

if(len > 0 && last >=0){
        char fmt[8];
        sprintf(fmt, "%%%dx", len);
        sscanf(hex, fmt, &aux);
        sprintf(buf[last],"%u", aux);
        for(; last < 1024; ++last){
            printf("%s", buf[last]);
        }
    }

-->

if(len > 0 && last >=0){
        char fmt[8];
        sprintf(fmt, "%%%dx", len);
        sscanf(hex, fmt, &aux);
        sprintf(buf[last],"%u", aux);  
    }
    for(; last < 1024; ++last){
            printf("%s", buf[last]);
     }

mujiok2003 2014-05-05

打赏
举报

sprintf + sscanf, 参考一下。

#include <stdio.h>
#include <string.h>
#include <limits.h>

int main()
{
	char const * const hex = "123456789abcdef";
	int len = strlen(hex);
	unsigned int aux = 0;
    static char buf[1024][32];
    int last = 1023;
	while(len > 8 && last >= 0){
		len -= 8;
		sscanf(hex + len, "%8x",&aux);
		sprintf(buf[last],"%u", aux);
		--last;
	}
	if(len > 0 && last >=0){
		char fmt[8];
		sprintf(fmt, "%%%dx", len);
		sscanf(hex, fmt, &aux);
		sprintf(buf[last],"%u", aux);
		for(; last < 1024; ++last){
			printf("%s", buf[last]);
		}
	}
	
	return 0;
}

「已注销」 2014-05-05

打赏
举报


#include<iostream>
#include<string.h>
#include<cmath>
using namespace std;


int ToDigit(int n){

if(n>='A'&&n<='F')
return n-'A'+10;
return n-'1'+1;
}


int main()
{

	int nlength, sum=0;
    char arr[10];
    cout<<"请输入一个十六进制数(字母需大写):"<<endl;
	cin>>arr;
	nlength=strlen(arr);
	for(int i=0;i<=nlength-1;i++)
	{
sum+=ToDigit(arr[i])*pow(16,nlength-1-i);

	}
cout<<"转制结果为:"<<sum<<endl;

return 0;
}
/*
请输入一个十六进制数(字母需大写):
1F
转制结果为:31

Process returned 0 (0x0)   execution time : 1.966 s
Press any key to continue.
*/

buyong 2014-05-05

打赏
举报

加载更多回复（4）

求十六进制转十进制

相关推荐