X进制转 X进制 (不全（持续更新））

龍隱川_夜無思☄️

2025-07-16 12:57:37

发布于：浙江

44阅读

0回复

0点赞

进制转换是十分常见的，今天我就分享一些 X进制转 X进制
而且，其实有些就是对照着反过来

先把这些吃透吧：

D ：Decimal (十进制)
B ：Binary (二进制)
O ：Octal (八进制)
H ：Hexadecimal (十六进制)
二进制 以 0b 开头的数字，如：int x = 0b1101111;
二进制里只有 [0 , 1]
八进制 以 0 开头的数字，如：int x = 0157;
八进制里有 [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7]
十进制 就是正常的数字，如：int x = 111;
十进制里有 [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9]
十六进制 以 0x 开头的数字，如：int x = 0x6F;
十六进制里有 [0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , A(a)代替10 , B(b)代替11 , C(c)代替12 , D(d)代替13 , E(e)代替14 , F(f)代替15]
哦，对了。这里还是提一下这老掉牙的知识点： $n^0$ = 1(n可以是任何非零的数(包括整数,小数,正数,负数)) 不知道为什么的点点我

二进制转十进制(整数)：

首先我们得知道二进制转十进制（B->D）其实就是二进制从右往左，各个位上依次乘以 $2^x$ 即可（x从0开始（当前这位是0也要乘））
如：
10011B = ( )D
1 × $2^4$ + 0 × $2^3$ + 0 × $2^2$ + 1 × $2^1$ + 1 × $2^0$ = 16 + 0 + 0 + 2 + 1 = 19
所以 10011B = 19D

因此，我们可以得到以下代码：

void ZS_B_D(int n){ // 二进制转十进制(整数)
    int ans = 0,power = 1;//ans是最终答案,power是当前的x(x为 2的x次方 中的x)
    while(n){
        ans += (n % 10) * power; 
        power *= 2;
        n /= 10;
    }
    cout << ans;
    return ;
}

十分简洁!

十进制转二进制(整数)：

十进制转二进制（D->B)，大家应该并不感到陌生，其实就是不断除以2取余（直到商为0），余数从下往上倒序输出就行啦。
如：
35D = ( )B
35 ÷ 2 = 17 …… 1
17 ÷ 2 = 8 …… 1
8 ÷ 2 = 4 …… 0
4 ÷ 2 = 2 …… 0
2 ÷ 2 = 1 …… 0
1 ÷ 2 = 0 …… 1
倒序输出为100011
所以 35D = 100011B

因此，我们可以得到以下代码：

void ZS_D_B(int n){ // 十进制转二进制(整数)
    vector<int> ve;
    do {
        ve.push_back(n % 2);
        n /= 2;
    } while(n);
    //得到答案倒序输出
    /*
    reverse(ans.begin(),ans.end());
    for(int i = 0;i <=ve.size() - 1;i--){
        cout << ve[i];
    }
    *///这样可以
    for(int i = ve.size() - 1;i >= 0;i--){
        cout << ve[i];
    }
    //这样也可以
    return ;
}

简洁明了!

二进制转十六进制(整数)：

稍难一丢丢的转化，会了这个，二进制转八进制（B->O）你也就会了，二进制转十六进制（B->H）就是从最右边起，每四个二进制位为一个十六进制位（就是把这四个二进制位转成十进制（如果 $这个十进制数 \geq 10$ 那么替换成字母）），不足四位添加前导0。记得倒序输出哦！
举个例子：
10110B = ( )H
10110 拆成一个四位和一个一位（ $\color{red}1$ 和 $\color{blue}0110$ )
因为是从右往左，所以先看 0110B
0110B = 6D 加入ve动态数组（代码中有）
然后再看1B
1不足四位，补前导零3个 $\color{silver}000$ $\color{blak}1$
0001B = 1D 加入ve动态数组（代码中有）
然后倒序输出为16H
所以 10110B = 16H
再举个特殊的例子：
101110B = ( )H
101110 拆成一个四位和一个两位（ $\color{red}10$ 和 $\color{blue}1110$ )
因为是从右往左，所以先看 1110B
1110B = 14D
显然 $14 \geq 10$ 了，所以要转成字母，14的字母为E，所以将E加入ve动态数组（代码中有）
然后再看10B
1不足四位，补前导零2个 $\color{silver}00$ $\color{blak}10$
0010B = 2D 加入ve动态数组（代码中有）
然后倒序输出为2EH
所以 101110B = 2EH

因此，我们可以得到以下代码：

void ZS_B_H(int n){ // 二进制转十六进制(整数)
    vector<int> ve;
    //拆分二进制
    do {
        ve.push_back(n % 10);
        n /= 10;
    } while(n);
    string ans;//存储十六进制的结果
    reverse(ve.begin(),ve.end());//反转数组
    // 补零使位数为4的倍数（高位补零）
    int padLen = (4 - (ve.size() % 4)) % 4;
    for (int i = 0; i < padLen; i++) {
        ve.insert(ve.begin(), 0);
    }
    // 每四位二进制数转成十六进制
    for (int i = 0; i < ve.size(); i += 4) {
        int s = 0;
        for (int j = i; j < i + 4; j++) {
            s = s * 2 + ve[j]; // 二进制转十进制
        }
        if (s < 10) ans += '0' + s;
        else ans += 'A' + (s - 10);
    }
    cout << ans;
    return ;
}

有点难，慢慢理解哦！

二进制转八进制(整数)：

既然你已经会了二进制转十六进制（B->H），约等于你会了二进制转八进制（B->O），因为二进制转八进制就是从最右边起，每三个二进制位为一个八进制位（就是把这三个二进制位转成十进制），不足三位添加前导0。还是要倒序输出哦！
举个例子：
1010B = ( )O
1010 拆成一个三位和一个一位（ $\color{red}1$ 和 $\color{blue}010$ )
因为是从右往左，所以先看 010B
010B = 2D 加入ve动态数组（代码中有）
然后再看1B
1不足三位，补前导零2个 $\color{silver}00$ $\color{blak}1$
001B = 1D 加入ve动态数组（代码中有）
然后倒序输出为12O
所以 1010B = 12O
是不是和二进制转十六进制一样啊！

因此，我们可以得到以下代码：

void ZS_B_O(long long n){//二进制转八进制(整数)
    //提取各个位置上的数字。
    vector<long long> ve;
    do {
        ve.push_back(n % 10);
        n /= 10;
    } while(n);
    string ans; //存储八进制答案
    for(int i = 0;i < ve.size();i += 3){
        long long s = 0;//算这三位(B)的值(D)是多少
        int power = 0;//见第一个
        for(int j = i;j <= min((int)ve.size() - 1,i + 2);j++){
            s += ve[j] * pow(2,power)//二进制转十进制
            power++;
        }
        ans += s + '0';
    }
    reverse(ans.begin(),ans.end()); //反转数组
    cout << ans;
    return ;
}

如果你会二进制转十六进制，那你一定会二进制转八进制
~~（不会二进制转八进制的说明你得去看医生了哦！）~~

八进制转二进制（整数）：

说白了，就是倒推嘛，既然二进制转八进制是三位二进制数位为一位八进制数位，那反过来，就是以一位八进制数位转成三位二进制数位。
给个例子就好理解很多了（对照上面）：
1010B = ( )O
12O = ( )B
12拆开，为1和2
2的二进制为010
1的二进制为001
合起来（从右往左）为001010，去前导零为1010。
所以 12O = 1010B
是不是就是二进制转八进制反过来啊！

因此，我们可以得到以下代码：

void ZS_B_O(long long n){//八进制转二进制(整数)
    vector<long long> ve;
    do {
        int b = n % 10;
        vector<long long> temp; // 临时存储当前八进制位的二进制
        // 转换当前八进制位为二进制
        do {
            temp.push_back(b % 2);
            b /= 2;
        } while(b);
        // 反转当前位的二进制
        reverse(temp.begin(), temp.end());
        // 补零至3位
        while(temp.size() < 3) {
            temp.push_back(0);
        }
        ve.insert(ve.end(), temp.begin(), temp.end()); //加入二进制数组
        n /= 10;
    } while(n);
    reverse(ve.begin(), ve.end()); // 反转数组  
    // 输出结果
    int flag = 1;
    for(int i = 0; i < ve.size(); i++){
        if(ve[i] != 0){
            flag = 0;
        }
        if(flag == 0){
            cout << ve[i];
        } 
    }
    return ;
}

对照着理解哈！不确定对不对，谨慎使用哦！

十六进制转二进制（整数）：

说白了，就是和八进制转二进制和二进制转十六进制差不多，就是倒推嘛，既然二进制转十六进制是四位二进制数位为一位十六进制数位，那反过来，就是以一位十六进制数位转成四位二进制数位。
给个例子就好理解很多了（对照上面）：
16H = ( )B
16拆开，为1和6
6的二进制为0110
1的二进制为0001
合起来（从右往左）为00010110，去前导零为10110。
所以 16H = 10110B
是不是就是二进制转十六进制反过来啊！

因此，我们可以得到以下代码：

void ZS_H_O(string n) { // 十六进制转二进制(整数)
    vector<int> ve;
    for (int i = 0; i < n.size(); i++) {
        vector<int> temp;
        int s = 0;
        //转换十六进制字符为数值
        if (n[i] >= '0' && n[i] <= '9') {
            s = n[i] - '0';
        } else if (n[i] >= 'A' && n[i] <= 'F') {
            s = n[i] - 'A' + 10;
        } else if (n[i] >= 'a' && n[i] <= 'f') {
            s = n[i] - 'a' + 10;
        }
        // 转换为二进制（4位），并补零
        do {
            temp.push_back(s % 2);
            s /= 2;
        } while (s > 0);
        while (temp.size() < 4) {
            temp.push_back(0);
        }
        // 合并到结果（逆序，因为低位先插入）
        ve.insert(ve.end(), temp.rbegin(), temp.rend()); 
    }
    int flag = 1;
    bool hasOutput = false;
    for (int i = 0; i < ve.size(); i++) {
        if (flag == 1&& ve[i] == 0) continue; // 跳过前导零
        flag = 0;
        cout << ve[i];
        hasOutput = true;
    }
    if (hasOutput == false) {
        cout << "0";
    }
}

也是对照着理解哈！不确定对不对，谨慎使用哦！
建议4个（二进制转八进制，八进制转二进制，二进制转十六进制，十六进制转二进制）一起理解

十进制转N进制(整数)：

十进制转N进制（D->N)，其实和十进制转二进制（D->B)可以说一模一样，就是不断除以N取余（直到商为0），余数从下往上倒序输出就行啦。
如：
35D = ( )(三进制)
也就是要我们将十进制转三进制，那么N=3(三(三进制))
35 ÷ 3 = 11 …… 2
11 ÷ 3 = 3 …… 2
3 ÷ 3 = 1 …… 0
1 ÷ 3 = 0 …… 1；
倒序输出为1022
所以 35D = 1022(三进制）

因此，我们可以得到以下代码：

void ZS_D_n(int q, int s){ //十进制转N进制(整数) 
    vector<char> ve;
    do {
        if(q > 10 && s % q > 9){
            ve.push_back('A' + s % q - 10);
        } else {
            ve.push_back(s % q + '0');
        }
        s /= q;
    } while(s);
    reverse(ve.begin(),ve.end()); //反转数组
    for(int i = 0;i < ve.size();i++){
        cout << ve[i];
    }
    return ;
}

很简单吧！

N进制转十进制(整数)：

首先我们得知道N进制转十进制（N->D）,其实和二进制转十进制（B->D)可以说一模一样,就是N进制从右往左，各个位上依次乘以 $N^x$ 即可（x从0开始（当前这位是0也要乘））
如：
1022(三进制(上面的例子，可以用来验证)) = ( )D
也就是要我们将三进制转十进制，那么N=3(三(三进制))
1 × $3^3$ + 0 × $3^2$ + 2 × $3^1$ + 2 × $3^0$ = 27 + 0 + 6 + 2 = 35D
所以 1022(三进制) = 35D

因此，我们可以得到以下代码：

void ZS_n_D(int q,string s){ // N进制转十进制(整数) 
    vector<int> ve;
    for(int i = 0;i < s.size();i++){
        if(s[i] >= '0' && s[i] <= '9') ve.push_back(s[i] - '0');
        else ve.push_back(s[i] - 55); //处理超过10的情况(字母代替)
    }
    reverse(ve.begin(),ve.end()); //反转数组
    long long ans = 0,power = 0;
    //输出
    for(int i = 0;i < ve.size();i++){
        ans += ve[i] * pow(q,power);
        power++;
    }
    cout << ans;
    return ;
}

也十分简单

拉个番外：

十进制小数转二进制小数

采用"乘2取整，顺序排列"法:
小数部分(D)乘2，取整数部分(一定是0或1)加入二进制数组中，将小数部分(D)取出，再乘2……重复以上步骤，直到积中小数部分为0（没有小数部分）或者达到所要求的精度为止。
如：
10.25(D) = ( )B
整数部分正常算：10(D) = 1010(B)
小数部分：
0.125 × 2 = 0.25 -> 0
0.25 × 2 = 0.5 -> 0
0.5 × 2 = 1.0 -> 1
顺序排列为 001(B)
合起来，点上小数点为：1010.001
所以 10.125(D) = 1010.001(B)

因此，我们能得到以下代码：

void XS_D_B(double n,int x){ // 十进制转二进制(小数) n为要转的十进制小数，x为精度(我这边，x = 0就是无精度)
    int zs = (int)n; //整数部分
    double xs = n - zs; //小数部分
    //调用函数，直接处理整数部分
    ZS_D_B(zs);
    cout << ".";//输出小数点
    //处理小数部分
    vector<int> ans2;
    int flag = 0;
    if(x == 0) flag = 1;
    while (xs > 0 && (x == 0 || flag < x)) { //判断小数部分(xs)的小数部分是否为0，与因为我这边，x = 0就是无精度所以这里判断的是是否为无精度与是否已到所需精度
        xs *= 2;
        ans2.push_back((int)xs);
        xs = xs - (int)xs;
        flag++;
    }
    //顺序输出，不需要反转数组
    for(int i = 0;i < ans2.size();i++){
        cout << ans2[i];
    }
    return ;
}

不确定对不对，谨慎使用哦！

其实合理利用 ZS_n_D( ) 和 ZS_D_n( )就可以做到N进制转M进制了。
不过大部分的函数都得是整数入参，没法处理小数哦。(只有一个可以处理)

完整版代码：

#include<bits/stdc++.h>
using namespace std;

void ZS_B_D(int n){ // 二进制转十进制(整数)
    int ans = 0,power = 1;
    while(n){
        ans += (n % 10) * power; 
        power *= 2;
        n /= 10;
    }
    cout << ans;
    return ;
}

void ZS_D_B(int n){ // 十进制转二进制(整数)
    vector<int> ve;
    do {
        ve.push_back(n % 2);
        n /= 2;
    } while(n);
    for(int i = ve.size() - 1;i >= 0;i--){
        cout << ve[i];
    }
    return ;
}

void ZS_B_H(int n){ // 二进制转十六进制(整数)
    vector<int> ve;
    //拆分二进制
    do {
        ve.push_back(n % 10);
        n /= 10;
    } while(n);
    string ans;//存储十六进制的结果
    reverse(ve.begin(),ve.end());//反转数组
    // 补零使位数为4的倍数（高位补零）
    int padLen = (4 - (ve.size() % 4)) % 4;
    for (int i = 0; i < padLen; i++) {
        ve.insert(ve.begin(), 0);
    }
    // 每四位二进制数转成十六进制
    for (int i = 0; i < ve.size(); i += 4) {
        int s = 0;
        for (int j = i; j < i + 4; j++) {
            s = s * 2 + ve[j]; // 二进制转十进制
        }
        if (s < 10) ans += '0' + s;
        else ans += 'A' + (s - 10);
    }
    cout << ans;
    return ;
}

void ZS_B_O(long long n){//二进制转八进制(整数)
    vector<long long> ve;
    do {
        ve.push_back(n % 10);
        n /= 10;
    } while(n);
    string ans;
    for(int i = 0;i < ve.size();i += 3){
        long long s = 0;
        int power = 0;
        for(int j = i;j <= min((int)ve.size() - 1,i + 2);j++){
            s += ve[j] * pow(2,power);
            power++;
        }
        ans += s + '0';
    }
    reverse(ans.begin(),ans.end()); //反转数组
    cout << ans;
    return ;
}

void ZS_D_n(int q, int s){ //十进制转N进制(整数) 
    vector<char> ve;
    do {
        if(q > 10 && s % q > 9){
            ve.push_back('A' + s % q - 10);
        } else {
            ve.push_back(s % q + '0');
        }
        s /= q;
    } while(s);
    reverse(ve.begin(),ve.end()); //反转数组
    for(int i = 0;i < ve.size();i++){
        cout << ve[i];
    }
    return ;
}

void ZS_n_D(int q,string s){ // N进制转十进制(整数) 
    vector<int> ve;
    for(int i = 0;i < s.size();i++){
        if(s[i] >= '0' && s[i] <= '9') ve.push_back(s[i] - '0');
        else ve.push_back(s[i] - 55);
    }
    reverse(ve.begin(),ve.end()); //反转数组
    long long ans = 0,power = 0;
    for(int i = 0;i < ve.size();i++){
        ans += ve[i] * pow(q,power);
        power++;
    }
    cout << ans;
    return ;
}

int main(){
    int x;
    cin >> x;
    ZS_B_H(x);
	return 0;
}