#include<iostream>
#include <bitset>//2
using namespace std;
int main() {
	int num1 = 10;
	cout << oct << num1 << endl;  // 输出八进制形式的数字
	int num2 = 15;
	cout << hex << num2 <<endl;  // 输出十六进制形式的数字
	int num3 = 15;
	cout << dec << num3 <<endl;  // 输出十进制形式的数字
	int num4 = 5;
	bitset<4> binaryRepresentation(num4);  // 将十进制数5转换为4位二进制表示
	cout << binaryRepresentation << endl; 
	return 0;
}

二进制转八进制

• 二进制数 101101.101 转换为八进制数是 55.5。
• 二进制数 111001.011 转换为八进制数是 71.3。
• 二进制数 100110.11 对应的八进制数是 46.6。

八进制转二进制

• 八进制数 65.3 转换为二进制数是 110101.011。
• 八进制数 47.2 转换为二进制数是 100111.01。
• 八进制数 32.6 对应的二进制数是 011010.110。

二进制转八进制

1. 将二进制数 101101.101 转换为八进制数。
2. 把二进制数 111001.011 转换为八进制数。
3. 二进制数 100110.11 对应的八进制数是多少？

八进制转二进制

1. 将八进制数 65.3 转换为二进制数。
2. 把八进制数 47.2 转换为二进制数。
3. 八进制数 32.6 对应的二进制数是多少？

二进制转十六进制

1. 将二进制数 1101101.101 转换为十六进制数。
2. 把二进制数 1011101.011 转换为十六进制数。
3. 二进制数 1110010.11 对应的十六进制数是多少？

十六进制转二进制

1. 将十六进制数 3A.7 转换为二进制数。
2. 把十六进制数 2F.4 转换为二进制数。
3. 十六进制数 1E.6 对应的二进制数是多少？

二进制转十进制

• 二进制数 (101.101) 转换为十进制数是 (5.625)。
• 二进制数 (1101.011) 转换为十进制数是 (13.375)。
• 二进制数 (1001.11) 对应的十进制数是 (9.75)。

十进制转二进制

• 十进制数 (25.625) 转换为二进制数是 (11001.101)。
• 十进制数 (37.375) 转换为二进制数是 (100101.011)。
• 十进制数 (18.8125) 对应的二进制数是 (10010.1101)。

二进制转十进制

1. 将二进制数 101.101 转换为十进制数。
2. 把二进制数 1101.011 转换为十进制数。
3. 二进制数 1001.11 对应的十进制数是多少？

十进制转二进制

1. 将十进制数 25.625 转换为二进制数。
2. 把十进制数 37.375 转换为二进制数。
3. 十进制数 18.8125 对应的二进制数是多少？

小数的进制转换在编程和数学中都较为常用，下面为你详细介绍小数在二进制、八进制、十进制、十六进制之间的转换方法。

十进制小数转换为其他进制

将十进制小数转换为其他进制，通常采用“乘基取整”法，“基”指的是目标进制的基数。以下是具体步骤：

1. 用小数部分乘以目标进制的基数。
2. 取乘积的整数部分作为目标进制小数的一位。
3. 取乘积的小数部分继续乘以基数，重复步骤1和2，直到小数部分为0或者达到所需的精度。

示例：将十进制小数 0.625 转换为二进制

• 第一步：(0.625×2 = 1.25)，整数部分是 1，小数部分是 0.25。
• 第二步：(0.25×2 = 0.5)，整数部分是 0，小数部分是 0.5。
• 第三步：(0.5×2 = 1.0)，整数部分是 1，小数部分是 0，转换结束。

所以，十进制小数 0.625 转换为二进制是 0.101。

其他进制小数转换为十进制

将其他进制小数转换为十进制，采用“按权相加”法。每一位数字乘以该位的权值（基数的负幂次方），然后将所有结果相加。

示例：将二进制小数 0.101 转换为十进制

• 第一位：(1×2^{-1}=0.5)
• 第二位：(0×2^{-2}=0)
• 第三位：(1×2^{-3}=0.125)

将结果相加：(0.5 + 0 + 0.125 = 0.625)

所以，二进制小数 0.101 转换为十进制是 0.625。

二进制与八进制、十六进制之间的转换

二进制与八进制

• 二进制转八进制：从小数点开始，分别向左右每三位二进制数一组进行划分，不足三位的在左边或右边补 0，然后将每组二进制数转换为对应的八进制数。
• 八进制转二进制：将每一位八进制数转换为对应的三位二进制数。

示例

• 二进制 0.101 转八进制：(0.101)本身就是一组三位二进制数，对应的八进制数是 0.5。
• 八进制 0.5 转二进制：八进制的 5 对应的二进制是 101，所以结果是 0.101。

二进制与十六进制

• 二进制转十六进制：从小数点开始，分别向左右每四位二进制数一组进行划分，不足四位的在左边或右边补 0，然后将每组二进制数转换为对应的十六进制数。
• 十六进制转二进制：将每一位十六进制数转换为对应的四位二进制数。

示例

• 二进制 0.1010 转十六进制：(0.1010)对应的十六进制数是 0.A。
• 十六进制 0.A 转二进制：十六进制的 A 对应的二进制是 1010，所以结果是 0.1010。

总结

小数进制转换的关键在于掌握“乘基取整”和“按权相加”的方法，以及二进制与八进制、十六进制之间的分组转换规则。多做一些练习，就能熟练掌握这些转换方法。

#include<iostream>
using namespace std;
int main() {
	
	//int binaryNumber = 0b101;  // 这是二进制数101，转换为十进制是5
	//cout<<binaryNumber;
	//int octalNumber = 012;  // 这是八进制数12，转换为十进制是10
	//cout<<octalNumber;
	//int hexadecimalNumber = 0xA;  // 这是十六进制数A，转换为十进制是10
	//cout<<hexadecimalNumber;
	//int decimalNumber = 123;  // 这是一个十进制数
	//cout<<decimalNumber;
	return 0;
}

以下是在C++中将不同进制的数赋值给int类型变量的方法：

十进制赋值

在C++中，直接书写的整数常量默认就是十进制数，所以可以直接进行赋值操作。例如：

int decimalNum = 123;  // 这里123就是十进制数，直接赋值给int类型变量decimalNum

二进制赋值

从C++14标准开始，可以使用0b或0B前缀来表示二进制字面量，并赋值给int类型变量。示例代码如下：

int binaryNum = 0b1010;  // 0b前缀表示这是二进制数1010，其十进制值为10，赋值给int类型变量binaryNum

八进制赋值

在C++中，以0（零）开头的整数常量会被视为八进制数，按照这样的规则就能将八进制数赋值给int类型变量。例如：

int octalNum = 012;  // 以0开头表示八进制数12，其十进制值为10，赋值给int类型变量octalNum

十六进制赋值

使用0x或0X前缀来表示十六进制数，进而可将其赋值给int类型变量。例如：

int hexadecimalNum = 0xA;  // 0x前缀表明这是十六进制数A，其十进制值为10，赋值给int类型变量hexadecimalNum

以下是一个完整的示例程序，展示了各种进制数赋值给int变量以及后续输出（以十进制形式输出查看赋值结果）的情况：

#include <iostream>
int main() {
    // 十进制赋值与输出
    int decimalNum = 123;
    std::cout << "十进制数赋值后的十进制输出: " << decimalNum << std::endl;

    // 二进制赋值与输出
    int binaryNum = 0b1010;
    std::cout << "二进制数（0b1010）赋值后的十进制输出: " << binaryNum << std::endl;

    // 八进制赋值与输出
    int octalNum = 012;
    std::cout << "八进制数（012）赋值后的十进制输出: " << octalNum << std::endl;

    // 十六进制赋值与输出
    int hexadecimalNum = 0xA;
    std::cout << "十六进制数（0xA）赋值后的十进制输出: " << hexadecimalNum << std::endl;

    return 0;
}

在上述代码中：

• 首先定义了不同进制表示的数并赋值给对应的int变量。
• 然后通过std::cout输出语句，以十进制的形式展示了这些变量的值，以此验证不同进制数赋值给int变量的操作是否正确。

1. 十进制数
   • 在C++ 中，没有特殊前缀或后缀的整数常量默认是十进制。例如：

int decimalNumber = 123;  // 这是一个十进制数

• 你可以使用std::cout输出十进制数：

#include <iostream>
int main() {
    int num = 123;
    std::cout << num << std::endl;
    return 0;
}

2. 二进制数
   • C++14开始支持二进制字面量。可以使用0b或0B前缀来表示二进制数。例如：

int binaryNumber = 0b101;  // 这是二进制数101，转换为十进制是5

• 如果要输出二进制形式的数字，可以使用bitset类（需要包含<bitset>头文件）。例如：

#include <iostream>
#include <bitset>
int main() {
    int num = 5;
    std::bitset<4> binaryRepresentation(num);  // 将十进制数5转换为4位二进制表示
    std::cout << binaryRepresentation << std::endl; 
    return 0;
}

• 上述代码中，std::bitset<4>表示创建一个4位的二进制表示对象，将num的值转换为二进制存储在这个对象中，然后输出这个二进制表示。

3. 八进制数
   • 在C++ 中，以0（零）开头的整数常量被视为八进制数。例如：

int octalNumber = 012;  // 这是八进制数12，转换为十进制是10

• 要将十进制数转换为八进制字符串形式输出，可以使用std::oct格式化标志。例如：

#include <iostream>
int main() {
    int num = 10;
    std::cout << std::oct << num << std::endl;  // 输出八进制形式的数字
    return 0;
}

• 上述代码中，std::oct告诉std::cout将后面的数字以八进制形式输出。

4. 十六进制数
   • C++ 中，以0x或0X开头的整数常量被视为十六进制数。例如：

int hexadecimalNumber = 0xA;  // 这是十六进制数A，转换为十进制是10

• 要将十进制数转换为十六进制字符串形式输出，可以使用std::hex格式化标志。例如：

#include <iostream>
int main() {
    int num = 15;
    std::cout << std::hex << num << std::endl;  // 输出十六进制形式的数字
    return 0;
}

• 另外，也可以使用printf函数（需要包含<stdio.h>头文件）来输出十六进制数，并且可以控制输出格式。例如：

#include <stdio.h>
int main() {
    int num = 255;
    printf("十六进制输出（小写字母）：%x\n", num);
    printf("十六进制输出（大写字母）：%X\n", num);
    return 0;
}

• 上述代码中，%x用于以十六进制小写字母形式输出数字，%X用于以十六进制大写字母形式输出数字。

https://www.bilibili.com/video/BV19Y411y7j2/

https://www.bilibili.com/video/BV1PK411g7vy/

https://www.bilibili.com/video/BV1K3411v75K

以下是一个使用C++语言实现将二进制数转换为十六进制数的代码示例：

#include <iostream>
#include <string>
#include <algorithm>

// 函数用于将二进制字符串转换为十六进制字符串
std::string binaryToHexadecimal(const std::string& binary) {
    std::string hexadecimal;
    int len = binary.length();
    // 确保二进制字符串长度是4的倍数，不足则在前面补0
    int remainder = len % 4;
    if (remainder!= 0) {
        std::string padding(4 - remainder, '0');
        hexadecimal = padding + binary;
    } else {
        hexadecimal = binary;
    }
    len = hexadecimal.length();
    // 每四位二进制数转换为一位十六进制数
    for (int i = 0; i < len; i += 4) {
        std::string segment = hexadecimal.substr(i, 4);
        int num = std::stoi(segment, nullptr, 2);
        char hexDigit;
        if (num < 10) {
            hexDigit = num + '0';
        } else {
            hexDigit = num - 10 + 'A';
        }
        hexadecimal.push_back(hexDigit);
    }
    return hexadecimal.substr(0, hexadecimal.length() / 4);
}

int main() {
    std::string binaryNumber;
    std::cout << "请输入二进制数: ";
    std::cin >> binaryNumber;
    std::string hexadecimalResult = binaryToHexadecimal(binaryNumber);
    std::cout << "二进制数 " << binaryNumber << " 转换后的十六进制数是: " << hexadecimalResult << std::endl;
    return 0;
}

以下是对上述代码的详细解释：

binaryToHexadecimal函数部分

1. 初始化与长度处理：
   • 首先定义了一个std::string类型的变量hexadecimal，用于存储最终转换得到的十六进制字符串。
   • 获取输入二进制字符串binary的长度len，接着检查其长度是否是4的倍数。因为每4位二进制数可以转换为1位十六进制数，若不是4的倍数，就在前面补0。通过计算余数remainder，如果remainder不为0，就创建一个包含4 - remainder个0的字符串padding，并将其与原二进制字符串拼接，得到新的hexadecimal；若remainder为0，则直接将原二进制字符串赋值给hexadecimal。
2. 分组转换：
   • 再次更新len为处理后的hexadecimal字符串的长度，然后通过for循环，每次步长为4，对hexadecimal字符串进行分组操作。在循环中，使用substr函数截取每一段长度为4的子字符串segment，这个子字符串就是要转换为十六进制的四位二进制数。
   • 通过std::stoi函数将这四位二进制数组成的字符串转换为整数（第三个参数2表示按照二进制进行解析），得到对应的十进制数值num。
3. 十六进制字符转换：
   • 根据得到的十进制数值num来确定十六进制字符。如果num小于10，直接将其加上字符'0'的ASCII码值，就可以得到对应的十六进制数字字符（例如，0对应的ASCII码值加上0得到字符'0'，5对应的ASCII码值加上0得到字符'5'）；如果num大于等于10，则用num减去10后再加上字符'A'的ASCII码值，就能得到对应的十六进制字母字符（例如，10减去10后加上'A'的ASCII码值得到字符'A'，15减去10后加上'A'的ASCII码值得到字符'F'）。将得到的十六进制字符hexDigit添加到hexadecimal字符串中。
4. 结果处理：
   • 最后，由于之前可能进行了补0操作，导致生成的hexadecimal字符串长度是最终十六进制结果的4倍，所以通过substr函数截取前面合适长度（即hexadecimal.length() / 4）的部分，返回最终的十六进制字符串。

main函数部分

1. 输入二进制数：
   • 定义了一个std::string类型的变量binaryNumber，用于存储用户输入的二进制数。通过std::cout输出提示信息，让用户输入二进制数，再使用std::cin从标准输入读取用户输入的二进制字符串并存储到binaryNumber变量中。
2. 调用转换函数并输出结果：
   • 调用binaryToHexadecimal函数，将用户输入的二进制数对应的字符串作为参数传入，函数返回转换后的十六进制字符串，存储在hexadecimalResult变量中。
   • 最后通过std::cout输出提示信息以及转换后的十六进制结果，展示给用户二进制数转换后的十六进制数情况。

这样，整个程序就能实现将用户输入的二进制数转换为十六进制数并输出的功能了。

以下是一个使用C++编写的将十六进制数转换为十进制数的代码示例：

#include <iostream>
#include <string>
#include <cctype>
using namespace std;

// 十六进制转十进制的函数
int hexToDecimal(const string& hexadecimal) {
    int decimal = 0;
    int power = 1;
    for (int i = hexadecimal.length() - 1; i >= 0; --i) {
        int digit;
        if (isdigit(hexadecimal[i])) {
            digit = hexadecimal[i] - '0';
        } else if (hexadecimal[i] >= 'A' && hexadecimal[i] <= 'F') {
            digit = hexadecimal[i] - 'A' + 10;
        } else if (hexadecimal[i] >= 'a' && hexadecimal[i] <= 'f') {
            digit = hexadecimal[i] - 'a' + 10;
        }
        decimal += digit * power;
        power *= 16;
    }
    return decimal;
}

int main() {
    string hexadecimalNumber;
    cout << "请输入十六进制数: ";
    cin >> hexadecimalNumber;
    int decimalResult = hexToDecimal(hexadecimalNumber);
    cout << "十六进制数 " << hexadecimalNumber << " 转换后的十进制数是: " << decimalResult << endl;
    return 0;
}

代码解释如下：

hexToDecimal函数部分

1. 变量定义：
   • 首先定义了decimal变量，用于存储最终转换得到的十进制数值，初始化为0。
   • power变量用于表示当前位对应的十六进制的权值，初始化为1（对应十六进制数最右边位的权值，即(16^0)）。
2. 循环遍历十六进制字符串：
   • 通过for循环从十六进制字符串的最后一位（最低位）开始向前遍历，循环条件为i >= 0，每次i减1。
3. 确定每一位对应的数值：
   • 使用isdigit函数判断当前字符是否为数字字符（0 - 9）。如果是数字字符，通过hexadecimal[i] - '0'的方式将字符转换为对应的整数值（例如字符'5'转换为整数5）。
   • 接着判断如果当前字符是大写字母A - F，通过hexadecimal[i] - 'A' + 10的方式将其转换为对应的十六进制数值（例如'A'转换为整数10）。
   • 同样，如果是小写字母a - f，使用hexadecimal[i] - 'a' + 10来转换为对应的十六进制数值。
4. 计算并更新结果：
   • 将确定好的当前位的数值digit乘以当前位的权值power，然后累加到decimal变量中，用于逐步计算出最终的十进制结果。
   • 之后，将power乘以16，以更新下一位对应的十六进制权值（因为十六进制每向左一位，权值变为原来的16倍）。

main函数部分

1. 输入十六进制数：
   • 首先定义了一个string类型的变量hexadecimalNumber，用于存储用户输入的十六进制数。
   • 通过cout输出提示信息，让用户输入十六进制数，然后使用cin从标准输入读取用户输入的十六进制字符串并存储到hexadecimalNumber变量中。
2. 调用转换函数并输出结果：
   • 调用hexToDecimal函数，将用户输入的十六进制数对应的字符串作为参数传入，函数返回转换后的十进制数值，存储在decimalResult变量中。
   • 最后通过cout输出提示信息以及转换后的十进制结果，向用户展示十六进制数转换后的十进制数值情况。

这样，整个程序就实现了将用户输入的十六进制数转换为十进制数并输出的功能。

1. 二进制转十进制
   • 原理：二进制数从右到左每一位数字乘以(2)的相应位数次幂（幂次从(0)开始），然后将所有结果相加。
   • 示例代码：

#include <iostream>
#include <string>
using namespace std;
int binaryToDecimal(const string& binary) {
    int decimal = 0;
    int power = 1;
    for (int i = binary.length() - 1; i >= 0; --i) {
        if (binary[i] == '1') {
            decimal += power;
        }
        power *= 2;
    }
    return decimal;
}
int main() {
    string binaryNumber = "1011";
    int decimalResult = binaryToDecimal(binaryNumber);
    cout << "二进制数 " << binaryNumber << " 转换为十进制数是: " << decimalResult << endl;
    return 0;
}

• 代码解释：
  • 在binaryToDecimal函数中，首先定义了decimal用于存储最终的十进制结果，power用于表示当前位的权值（初始为(1)，对应(2^0)）。
  • 然后从二进制数的最低位（即字符串的最后一个字符）开始遍历。如果当前位是1，就将power的值累加到decimal中。之后，power的值乘以(2)，以更新下一位的权值。
  • 最后，在main函数中调用binaryToDecimal函数并输出结果。

2. 八进制转十进制
   • 原理：八进制数从右到左每一位数字乘以(8)的相应位数次幂（幂次从(0)开始），然后将所有结果相加。
   • 示例代码：

#include <iostream>
#include <string>
using namespace std;
int octalToDecimal(const string& octal) {
    int decimal = 0;
    int power = 1;
    for (int i = octal.length() - 1; i >= 0; --i) {
        int digit = octal[i] - '0';
        decimal += digit * power;
        power *= 8;
    }
    return decimal;
}
int main() {
    string octalNumber = "73";
    int decimalResult = octalToDecimal(octalNumber);
    cout << "八进制数 " << octalNumber << " 转换为十进制数是: " << decimalResult << endl;
    return 0;
}

• 代码解释：
  • 在octalToDecimal函数中，decimal用于存储十进制结果，power用于表示当前位的权值（初始为(1)，对应(8^0)）。
  • 从八进制数的最低位开始遍历，将字符转换为对应的整数（通过octal[i]-'0'的方式），然后乘以当前位的权值power并累加到decimal中。之后，power的值乘以(8)，更新下一位的权值。
  • 在main函数中调用octalToDecimal函数并输出结果。

3. 十六进制转十进制
   • 原理：十六进制数从右到左每一位数字乘以(16)的相应位数次幂（幂次从(0)开始），然后将所有结果相加。其中，对于(A - F)（或(a - f)）需要转换为对应的(10 - 15)的值。
   • 示例代码：

#include <iostream>
#include <string>
using namespace std;
int hexadecimalToDecimal(const string& hexadecimal) {
    int decimal = 0;
    int power = 1;
    for (int i = hexadecimal.length() - 1; i >= 0; --i) {
        int digit;
        if (hexadecimal[i] >= '0' && hexadecimal[i] <= '9') {
            digit = hexadecimal[i] - '0';
        } else if (hexadecimal[i] >= 'A' && hexadecimal[i] <= 'F') {
            digit = hexadecimal[i] - 'A' + 10;
        } else if (hexadecimal[i] >= 'a' && hexadecimal[i] <= 'f') {
            digit = hexadecimal[i] - 'a' + 10;
        }
        decimal += digit * power;
        power *= 16;
    }
    return decimal;
}
int main() {
    string hexadecimalNumber = "1A";
    int decimalResult = hexadecimalToDecimal(hexadecimalNumber);
    cout << "十六进制数 " << hexadecimalNumber << " 转换为十进制数是: " << decimalResult << endl;
    return 0;
}

• 代码解释：
  • 在hexadecimalToDecimal函数中，decimal存储十进制结果，power用于表示当前位的权值（初始为(1)，对应(16^0)）。
  • 从十六进制数的最低位开始遍历，首先判断当前字符是数字还是字母。如果是数字0 - 9，通过hexadecimal[i]-'0'转换为对应的整数；如果是字母A - F或a - f，通过hexadecimal[i]-'A'+10或hexadecimal[i]-'a'+10转换为对应的整数（(10 - 15)）。然后将该数字乘以当前位的权值power并累加到decimal中，power的值乘以(16)以更新下一位的权值。
  • 在main函数中调用hexadecimalToDecimal函数并输出结果。

1. 十进制
   • 概念：十进制是我们日常生活中最常用的进制。它的基数是10，使用数字0 - 9来表示数值。每一位数字的权值是10的相应幂次，从右到左幂次依次递增，个位的权值是$10^0 = 1$，十位的权值是$10^1 = 10$，百位的权值是$10^2 = 100$，以此类推。
   • 在C++中的表示：在C++中，没有特殊标记的整数常量默认是十进制。例如，int num = 123;这里的123就是十进制数，表示1个100、2个10和3个1。
   • 应用场景：在大多数数学运算、用户输入输出（如读取用户输入的年龄、数量等）以及一般的程序逻辑处理中，十进制被广泛使用。
2. 二进制
   • 概念：二进制是计算机内部数据存储和处理的基础进制。它的基数是2，仅使用数字0和1。每一位数字的权值是2的相应幂次，从右到左幂次依次递增，最右边的位权值是$2^0 = 1$，下一位是$2^1 = 2$，再下一位是$2^2 = 4$，依此类推。
   • 在C++中的表示：在C++中，可以使用0b或0B前缀来表示二进制数。例如，int bin_num = 0b101;表示二进制数101，它转换为十进制是$1\times2^2+0\times2^1 + 1\times2^0=4 + 0+1 = 5$。
   • 应用场景：主要用于底层的计算机操作，如位运算（按位与&、按位或|、按位异或^等）。这些位运算在处理二进制数据时非常高效，例如在图像处理中对像素的位操作、网络协议中对数据位的处理等。
3. 八进制
   • 概念：八进制的基数是8，使用数字0 - 7来表示数值。每一位数字的权值是8的相应幂次，从右到左幂次依次递增，个位的权值是$8^0 = 1$，十位的权值是$8^1 = 8$，百位的权值是$8^2 = 64$，以此类推。
   • 在C++中的表示：在C++中，以0（零）开头的整数常量被视为八进制数。例如，int oct_num = 012;这个012是八进制数，转换为十进制是$2\times8^0+1\times8^1 = 2 + 8=10$。
   • 应用场景：在早期计算机编程中，由于八进制与二进制之间的转换较为方便（每三位二进制数可以转换为一位八进制数），所以在一些系统编程和文件权限设置等场景中有一定应用，不过现在使用相对较少。
4. 十六进制
   • 概念：十六进制的基数是16，使用数字0 - 9和字母A - F（或a - f）来表示数值，其中A - F（a - f）分别代表10 - 15。每一位数字的权值是16的相应幂次，从右到左幂次依次递增，个位的权值是$16^0 = 1$，十位的权值是$16^1 = 16$，百位的权值是$16^2 = 256$，以此类推。
   • 在C++中的表示：在C++中，以0x或0X开头的整数常量被视为十六进制数。例如，int hex_num = 0x1A;这里的0x1A是十六进制数，转换为十进制是$10\times16^0+1\times16^1 = 10 + 16 = 26$。
   • 应用场景：在计算机内存地址表示、颜色编码（如RGB颜色值常用十六进制表示）、硬件寄存器操作等方面广泛应用。因为一个字节（8位）可以方便地用两位十六进制数表示，这样在处理字节数据和多字节数据时更加简洁直观。

https://zhuanlan.zhihu.com/p/257162442

https://blog.csdn.net/djc3501558870/article/details/132217968

https://blog.csdn.net/weixin_47257473/article/details/122139807