二进制、八进制、十进制和十六进制的相互转换

printf 函数

printf 函数是 C 语言中用于将格式化的数据输出到尺度输出（通常是屏幕）的函数。它位于 stdio.h 头文件中，因此在使用之前需要包含该头文件。
printf 函数的格式说明符

格式说明符说明示例%d 或 %i输出或输入十进制有符号整数printf("%d", 10);
scanf("%d", &num);%u输出或输入十进制无符号整数printf("%u", 10U);
scanf("%u", &unsigned_num);%o输出或输入八进制无符号整数printf("%o", 012);
scanf("%o", &octal_num);%x 或 %X输出或输入十六进制无符号整数，%x 输出小写字母，%X 输出大写字母printf("%x", 0xFF);
scanf("%x", &hex_num);%f输出或输入单精度浮点数printf("%f", 3.14f);
scanf("%f", &float_num);%lf输出或输入双精度浮点数printf("%lf", 3.14159);
scanf("%lf", &double_num);%c输出或输入单个字符printf("%c", 'A');
scanf("%c", &char_var);%s输出或输入字符串（不包含空格，以空格或换行符竣事）printf("%s", "hello");
scanf("%s", str);%p输出指针的地址，以十六进制表现printf("%p", &ptr);
scanf("%p", &ptr);%e 或 %E以科学计数法输出或输入浮点数，%e 为小写，%E 为大写printf("%e", 12345.6789);
scanf("%e", &float_num);%g 或 %G根据数值大小自动选择 %f 或 %e 输出浮点数，%g 为小写，%G 为大写printf("%g", 0.0000123);
scanf("%g", &float_num);%n不输出任何内容，但将已输出的字符数存储在对应的整型变量中int num; printf("hello world%n", &num);
会将 11 存储在 num 中 高级格式化选项

格式说明符说明示例%[flags][width][.precision][length]specifier组合使用各种选项进行格式化输出或输入printf("%8.2f", 3.14159); 输出浮点数，宽度为 8，保留 2 位小数 Flags（标志）

标志说明示例-左对齐printf("%-8d", 10); 输出整数，宽度为 8，左对齐+强制输出正负号printf("%+d", 10); 输出 +10（空格）正数前输出空格，负数前输出负号printf("% d", 10); 输出 100用 0 添补宽度printf("%08d", 10); 输出整数，宽度为 8，不足用 0 添补#对于 %o，输出八进制数时加前缀 0；对于 %x 或 %X，输出十六进制数时加前缀 0x 或 0X；对于 %f、%e 或 %g，即使没有小数部门也输出小数点printf("%#o", 10); 输出 012

1. #include <stdio.h>
3. int main() {
4.     int num = 10;
7.     // 输出整数，宽度为 5，左对齐
8.     printf("整数: %-5d\n", num);
11.     return 0;
12. }

复制代码

Width（宽度）

说明示例指定最小输出宽度printf("%5d", 10); 输出整数，宽度为 5 Precision（精度）

说明示例对于浮点数，指定小数点后的位数；对于字符串，指定最大输出长度printf("%.2f", 3.14159); 保留 2 位小数

1. #include <stdio.h>
3. int main() {
4.     int num = 10;
5.     float f = 3.14159;
8.     // 输出整数，宽度为 5
9.     printf("整数: %5d\n", num);
12.     // 输出浮点数，保留两位小数
13.     printf("浮点数: %.2f\n", f);
16.     return 0;
17. }

复制代码

Length（长度）

长度修饰符说明示例h与 d、i、o、x 或 u 一起使用，表现短整型printf("%hd", (short)10);l与 d、i、o、x 或 u 一起使用，表现长整型；与 e、f 或 g 一起使用，表现双精度浮点数printf("%ld", (long)10L);
printf("%lf", 3.14);ll与 d、i、o、x 或 u 一起使用，表现长长整型printf("%lld", (long long)123456789012345LL);L与 e、f 或 g 一起使用，表现长双精度浮点数printf("%Lf", 3.14L); scanf 函数


scanf 函数是 C 语言中用于从尺度输入（通常是键盘）读取格式化数据的函数。同样位于 stdio.h 头文件中。
scanf 函数的格式说明符

格式说明符说明示例输入存储变量%d 或 %i十进制整数scanf("%d", &num);10int num;%u无符号十进制整数scanf("%u", &num);4294967295unsigned int num;%o八进制整数scanf("%o", &num);12int num;%x 或 %X十六进制整数scanf("%x", &num);<br>scanf("%X", &num);ff<br>FFint num;%f浮点数scanf("%f", &num);3.14159float num;%e 或 %E科学计数法表现的浮点数scanf("%e", &num);<br>scanf("%E", &num);3.141590e+00<br>3.141590E+00float num;%c单个字符scanf("%c", &ch);Achar ch;%s字符串scanf("%s", str);Hellochar str[50]; tips

• 对于 %s 格式说明符，scanf 函数会读取字符串直到遇到空格、制表符或换行符。如果要读取包含空格的字符串，可以使用 fgets 函数。
  
• 对于 %c 格式说明符，scanf 会读取下一个字符，包罗空格和换行符，所以如果前面有输入，可能需要处理多余的空格或换行符。
  

为了避免读取到换行符，可以在 %c 前加一个空格:

1. #include <stdio.h>
3. int main() {
4.     char ch1, ch2;
7.     // 读取字符，可能会读取到换行符
8.     scanf("%c", &ch1);
11.     // 读取下一个字符，跳过空格和换行符
12.     scanf(" %c", &ch2);
15.     printf("你输入的第一个字符是: %c\n", ch1);
16.     printf("你输入的第二个字符是: %c\n", ch2);
19.     return 0;
20. }

复制代码

使用 getchar 函数清除多余字符

1. #include <stdio.h>
3. int main() {
4.     char ch;
5.     scanf("%d");  // 假设前面有一个整数输入
6.     getchar();  // 读取并丢弃换行符
7.     scanf("%c", &ch);  // 读取字符
8.     return 0;
9. }

复制代码

二进制（Binary）

是一种以 2 为基数的计数系统，仅使用数字 0 和 1 来表现数值。通常，我们使用二进制数的位（bit）来表现数据，一个字节（byte）由 8 位二进制数组成。
二进制转十进制

从右往左，将二进制数的每一位乘以 2^n（n 从 0 开始），然后将结果相加。

1. 1011(二进制)表示：1 乘 2的三次方 + 0 乘 2的二次方 + 1 乘 2的一次方 + 1 乘 2的零次方
2.                 = 8 + 0 + 2 + 1
3.                 =11（十进制）

复制代码

 十进制转二进制

将十进制数除以 2，取余数，将商继续除以 2，直到商为 0。将每次得到的余数从下往上分列，就是对应的二进制数。

1. // 将十进制数 10 转换为二进制
3. 10 ÷ 2 = 5······0
4. 5 ÷ 2 = 2······1
5. 2 ÷ 2 = 1······0
6. 1 ÷ 2 = 0······1
7. //因此十进制的二进制从下往上排列余数 1010

复制代码

位运算符

按位与（&）

对两个操作数的每一位进行逻辑与操作（即当两位都为 1 时结果为 1，否则为 0）。

1. #include <stdio.h>
3. int main() {
4.     int a = 0b1010;  // 二进制表示，C99 标准开始支持，也可写成 10 然后通过其他方式理解其为二进制
5.     int b = 0b1100;
6.     int result = a & b;  // 按位与
7.     printf("按位与结果: %d\n", result);  // 输出为 8，即 0b1000
8.     return 0;
9. }

复制代码

按位或（|）

对两个操作数的每一位进行逻辑或操作（即当两位中至少有一位为 1 时结果为 1，否则为 0）。

1. #include <stdio.h>
3. int main() {
4.     int a = 0b1010;
5.     int b = 0b1100;
6.     int result = a | b;  // 按位或
7.     printf("按位或结果: %d\n", result);  // 输出为 14，即 0b1110
8.     return 0;
9. }

复制代码

按位异或（^）

对两个操作数的每一位进行逻辑异或操作（即当两位相异时结果为 1，相同时为 0）。

1. #include <stdio.h>
3. int main() {
4.     int a = 0b1010;
5.     int b = 0b1100;
6.     int result = a ^ b;  // 按位异或
7.     printf("按位异或结果: %d\n", result);  // 输出为 6，即 0b0110
8.     return 0;
9. }

复制代码

按位取反（~）

对操作数的每一位进行取反操作（即 0 变为 1，1 变为 0）。

1. #include <stdio.h>
3. int main() {
4.     int a = 0b1010;
5.     int result = ~a;  // 按位取反
6.     printf("按位取反结果: %d\n", result);  // 输出为 -11，即 0b1111111111111111111111111111110101
7.     return 0;
8. }

复制代码

左移（<<）

将操作数的二进制表现向左移动指定的位数，右边补 0。

1. #include <stdio.h>
3. int main() {
4.     int a = 0b1010;
5.     int result = a << 1;  // 左移 1 位
6.     printf("左移结果: %d\n", result);  // 输出为 20，即 0b10100
7.     return 0;
8. }

复制代码

右移（>>）

将操作数的二进制表现向右移动指定的位数，对于无符号数，左边补 0；对于有符号数，根据编译器和系统可能是补 0 或补符号位。

1. #include <stdio.h>
3. int main() {
4.     int a = 0b1010;
5.     int result = a >> 1;  // 右移 1 位
6.     printf("右移结果: %d\n", result);  // 输出为 5，即 0b0101
7.     return 0;
8. }

复制代码

二进制数的存储和表现

在内存中，整数通常以二进制补码的形式存储。对于有符号整数：

• 正数的补码就是其原码（二进制表现）。
  
• 负数的补码是其原码取反加 1。
  

1. #include <stdio.h>
3. int main() {
4.     int a = -5;
5.     // 原码：10000000 00000000 00000000 00000101
6.     // 反码：11111111 11111111 11111111 11111010
7.     // 补码：11111111 11111111 11111111 11111011
8.     printf("存储的二进制补码表示: %d\n", a);  // 输出为 -5
9.     return 0;
10. }

复制代码

原码

原码是最直观的表现有符号数的方法，它将最高位用作符号位（0 表现正数，1 表现负数），别的位表现数值的绝对值。

1. 原码：10000000 00000000 00000000 00000101
3. // 最高位 1 表示这个数是负数
4. // 其余位 0000000 00000000 00000000 00000101 表示数值部分，即 5。
5. //  因此，这个原码表示的是 -5。

复制代码

反码

反码是对原码除符号位外的所有位取反得到的。

1. 原码：10000000 00000000 00000000 00000101
3. // 符号位不变，仍然是 1
4. // 对其余位取反
5.     // 原码的数值部分 0000000 00000000 00000000 00000101 取反后得到 1111111 11111111 11111111 11111010。
6. 反码：11111111 11111111 11111111 11111010

复制代码

补码

补码是在反码的底子上加 1 得到的，它是盘算机中最常用的表现有符号数的方式，由于使用补码可以方便地进行加减运算。

1. 原码：10000000 00000000 00000000 00000101
2. 反码：11111111 11111111 11111111 11111010
3. //直接加 1
4. 11111111 11111111 11111111 11111010
5. + 00000000 00000000 00000000 00000001
6. 11111111 11111111 11111111 11111011
8. //补码：11111111 11111111 11111111 11111011

复制代码

为什么使用补码？

• 简化运算：使用补码可以将减法运算转换为加法运算，如许硬件只需要实现加法器就可以同时完成加法和减法运算。例如，对于 a - b，可以表现为 a + (-b)，而 -b 的补码可以通过 b 的补码取反加 1 得到。
  
  1. // 要计算 3 - 5，在计算机中会将其转换为 3 + (-5)
  3. // 3 的原码和补码相同
  4. 原码：00000000 00000000 00000000 00000011
  5. 补码：00000000 00000000 00000000 00000011
  7. // -5 的原码
  8. 原码：10000000 00000000 00000000 00000101
  9. 反码：11111111 11111111 11111111 11111010
  10. 补码：11111111 11111111 11111111 11111011
  12. //计算 3 + (-5)
  13. 00000000 00000000 00000000 00000011  (3 的补码)
  14. + 11111111 11111111 11111111 11111011  (-5 的补码)
  15. 11111111 11111111 11111111 11111110
  16. // 这是一个负数的补码
  17. // 将其转换回原码来查看结果
  18. // 先对补码取反加 1 得到原码
  20. // 补码：11111111 11111111 11111111 11111110
  21. // 取反：10000000 00000000 00000000 00000001
  22. // 加 1：10000000 00000000 00000000 00000010
  23. // 所以结果是 -2，即 3 - 5 = -2。

  复制代码
  
  
• 唯一表现零：使用原码和反码表现有符号数时，零有正零和负零两种表现方式，而使用补码表现时，零只有一种表现方式（全零）。
  

总结

• 原码：最直观，但在加减运算时需要单独处理符号位，未便于硬件实现。
  
• 反码：在原码底子上对数值位取反，但仍存在正负零的题目。
  
• 补码：在反码底子上加 1，解决了正负零题目，而且可以将减法转换为加法，方便硬件实现运算
  

二进制数的应用

标志位操作

使用二进制的位来表现差别的标志。

1. #include <stdio.h>
3. #define FLAG_A 0b0001
4. #define FLAG_B 0b0010
5. #define FLAG_C 0b0100
8. int main() {
9.     int flags = 0;
10.     flags |= FLAG_A;  // 设置 FLAG_A
11.     flags |= FLAG_B;  // 设置 FLAG_B
12.     if (flags & FLAG_A) {
13.         printf("FLAG_A 已设置\n");
14.     }
15.     if (flags & FLAG_B) {
16.         printf("FLAG_B 已设置\n");
17.     }
18.     if (flags & FLAG_C) {
19.         printf("FLAG_C 已设置\n");
20.     }
21.     return 0;
22. }

复制代码

位掩码

使用位掩码来提取或修改特定的位。

1. #include <stdio.h>
3. int main() {
4.     int num = 0b10101010;
5.     int mask = 0b00110000;
6.     int result = num & mask;  // 提取特定的位
7.     printf("提取结果: %d\n", result);  // 输出为 0b00100000
8.     return 0;
9. }

复制代码

八进制（Octal）

使用数字 0 到 7，在 C 语言中，以数字 0 开头表现八进制数。
八进制转十进制

从右往左，将八进制数的每一位乘以 8^n（n 从 0 开始），然后将结果相加。

1. 013 八进制 表示 = 1 乘 8的一次方 + 3 乘 8的零次方
2.                = 8 + 3
3.                = 11（十进制）

复制代码

十进制转八进制

将十进制数除以 8，取余数，将商继续除以 8，直到商为 0。将每次得到的余数从下往上分列，就是对应的八进制数。

1. 将十进制数 10 转换为八进制
3. 10 ÷ 8 = 1 ······ 2
4. 1 ÷ 8 = 0 ······ 1
6. // 结果是 012

复制代码

十进制（Decimal）

是我们日常生活中最常用的计数系统，使用数字 0 到 9。在 C 语言中，直接使用数字表现十进制数，例如 10, 255, 0 等。

1. 11（十进制）表示 = 1 乘 10的一次方 + 1 乘 10的零次方
2.                 = 10 + 1
3.                 = 11

复制代码

十六进制（Hexadecimal）

使用数字 0 到 9 和字母 A 到 F（或 a 到 f）表现，在 C 语言中，以 0x 或 0X 开头表现十六进制数。
十六进制转十进制

从右往左，将十六进制数的每一位乘以 16^n （n 从 0 开始），对于 A 到 F 的数字，其值分别为 10 到 15。将结果相加。

1. 0xFF 十六进制 表示 = 15 乘 16的一次方 + 15 乘 16的零次方
2.                   = 240 + 15
3.                   = 255

复制代码

十进制转十六进制

将十进制数除以 16，取余数，将商继续除以 16，直到商为 0。余数为 10 到 15 时用 A 到 F 表现，将每次得到的余数从下往上分列，就是对应的十六进制数。

1. 将十进制数 255 转换为十六进制
3. 255 ÷ 16 = 15 ······ 15 （F）
4. 15 ÷ 16 = 0 ······ 15 （F）
6. // 结果是 0xFF

复制代码

二进制与其他进制的转换

• 二进制转八进制
  
  
  
  • 方法一：先将二进制转十进制，再将十进制转八进制。
    1. // 假设我们有二进制数 101101
    2. // 二进制转十进制
    3. 1 * 2^5 + 0 * 2^4 + 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 1 * 2^0
    4. =32 + 0 + 8 + 4 + 0 + 1
    5. = 45（十进制）
    6. // 十进制转八进制
    7. 45 ÷ 8 = 5······5（余数）
    8. 5 ÷ 8 = 0······5（余数）
    10. // 所以八进制的结果是55

    复制代码
    1. #include <stdio.h>
    2. #include <math.h>
    4. // 二进制转十进制
    5. int binaryToDecimal(long long binary) {
    6.     int decimal = 0;
    7.     int power = 0;
    8.     while (binary > 0) {
    9.         decimal += (binary % 10) * pow(2, power);
    10.         binary /= 10;
    11.         power++;
    12.     }
    13.     return decimal;
    14. }
    16. // 十进制转八进制
    17. int decimalToOctal(int decimal) {
    18.     int octal = 0;
    19.     int i = 1;
    20.     while (decimal > 0) {
    21.         octal += (decimal % 8) * i;
    22.         decimal /= 8;
    23.         i *= 10;
    24.     }
    25.     return octal;
    26. }
    28. int main() {
    29.     long long binary = 101101;
    30.     int decimal = binaryToDecimal(binary);
    31.     int octal = decimalToOctal(decimal);
    32.     printf("二进制数 %lld 转换为八进制数是: %d\n", binary, octal);
    33.     return 0;
    34. }

    复制代码
    
    
  • 方法二（直接转换法）：从二进制数的小数点开始，向左（或向右）每三位一组划分（不够三位时，高位补0），然后将每组二进制数转换成对应的八进制数。
    1. // 由于 2^3 = 8，所以可以将二进制数按三位一组划分，每组二进制数可以直接对应一个八进制数
    2. // 对于二进制数 101101
    3. // 分组：101 101（高位补 0 后）
    4. // 101 对应八进制 5，101 对应八进制 5
    5. // 八进制结果是 55。

    复制代码
    1. #include <stdio.h>
    2. #include <string.h>
    4. // 二进制转八进制
    5. int binaryToOctalDirect(char *binary) {
    6.     int octal = 0;
    7.     int len = strlen(binary);
    8.     int i = 0;
    9.     while (i < len) {
    10.         int group = 0;
    11.         int base = 1;
    12.         for (int j = 0; j < 3 && i < len; j++) {
    13.             group += (binary[len - 1 - i] - '0') * base;
    14.             base *= 2;
    15.             i++;
    16.         }
    17.         octal = octal * 10 + group;
    18.     }
    19.     return octal;
    20. }
    22. int main() {
    23.     char binary[] = "101101";
    24.     int octal = binaryToOctalDirect(binary);
    25.     printf("二进制数 %s 转换为八进制数是: %d\n", binary, octal);
    26.     return 0;
    27. }

    复制代码
    
    
  
  
• 二进制转十六进制
  
  
  
  • 方法一：先将二进制转十进制，再将十进制转十六进制。
    1. // 假设我们有二进制数 1101101
    3. // 二进制转十进制
    5. 1 * 2^6 + 1 * 2^5 + 0 * 2^4 + 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 1 * 2^0
    6. =64 + 32 + 0 + 8 + 4 + 0 + 1
    7. =109(十进制)
    9. // 十进制转十六进制
    10. 109 ÷ 16 =6······13（余数，用 D 表示）
    11. 6 ÷ 16 =0······6
    12. // 十六进制结果是 6D

    复制代码
    1. #include <stdio.h>
    2. #include <math.h>
    4. // 二进制转十进制
    5. int binaryToDecimal(long long binary) {
    6.     int decimal = 0;
    7.     int power = 0;
    8.     while (binary > 0) {
    9.         decimal += (binary % 10) * pow(2, power);
    10.         binary /= 10;
    11.         power++;
    12.     }
    13.     return decimal;
    14. }
    16. // 十进制转十六进制
    17. void decimalToHex(int decimal) {
    18.     char hex[100];
    19.     int i = 0;
    20.     while (decimal > 0) {
    21.         int remainder = decimal % 16;
    22.         if (remainder < 10) {
    23.             hex[i++] = remainder + '0';
    24.         } else {
    25.             hex[i++] = remainder - 10 + 'A';
    26.         }
    27.         decimal /= 16;
    28.     }
    29.     for (int j = i - 1; j >= 0; j--) {
    30.         printf("%c", hex[j]);
    31.     }
    32.     printf("\n");
    33. }
    35. int main() {
    36.     long long binary = 1101101;
    37.     int decimal = binaryToDecimal(binary);
    38.     printf("二进制数 %lld 转换为十六进制数是: ", binary);
    39.     decimalToHex(decimal);
    40.     return 0;
    41. }

    复制代码
    
    
  • 方法二（直接转换法）：从二进制数的小数点开始，向左（或向右）每四位一组划分（不够四位时，高位补0），然后将每组二进制数转换成对应的十六进制数。
    1. // 由于 2^4=16，所以可以将二进制数按四位一组划分，每组二进制数可以直接对应一个十六进制数
    3. // 对于二进制数 1101101
    5. 分组：0110 1101（高位补 0 后）
    7. 0110 对应十六进制 6，1101 对应十六进制 D。
    8. 所以十六进制结果是 6D。

    复制代码
    1. #include <stdio.h>
    2. #include <string.h>
    4. // 二进制转十六进制
    5. void binaryToHexDirect(char *binary) {
    6.     int len = strlen(binary);
    7.     for (int i = len - 1; i >= 0; i -= 4) {
    8.         int group = 0;
    9.         int base = 1;
    10.         for (int j = 0; j < 4 && i - j >= 0; j++) {
    11.             group += (binary[i - j] - '0') * base;
    12.             base *= 2;
    13.         }
    14.         if (group < 10) {
    15.             printf("%d", group);
    16.         } else {
    17.             printf("%c", group - 10 + 'A');
    18.         }
    19.     }
    20.     printf("\n");
    21. }
    23. int main() {
    24.     char binary[] = "1101101";
    25.     printf("二进制数 %s 转换为十六进制数是: ", binary);
    26.     binaryToHexDirect(binary);
    27.     return 0;
    28. }

    复制代码
    
    
  
  

八进制与十六进制的转换

• 八进制转十六进制
  
  
  
  • 方法一：先将八进制转十进制，再将十进制转十六进制。
    1. // 假设我们有八进制数 345。
    3. // 八进制转十进制
    4. = 3 * 8^2 + 4 * 8^1 + 5 * 8^0
    5. =192 + 32 +5
    6. =229(十进制）
    8. 十进制转十六进制
    10. 229 ÷ 16 =14······ 5 （余数，用 5 表示）
    12. 14 ÷ 16 =0······ 14  （余数，用 E 表示）
    14. //十六进制结果是 E5

    复制代码
    1. #include <stdio.h>
    2. #include <math.h>
    4. // 八进制转十进制
    5. int octalToDecimal(int octal) {
    6.     int decimal = 0;
    7.     int power = 0;
    8.     while (octal > 0) {
    9.         decimal += (octal % 10) * pow(8, power);
    10.         octal /= 10;
    11.         power++;
    12.     }
    13.     return decimal;
    14. }
    16. // 十进制转十六进制
    17. void decimalToHex(int decimal) {
    18.     char hex[100];
    19.     int i = 0;
    20.     while (decimal > 0) {
    21.         int remainder = decimal % 16;
    22.         if (remainder < 10) {
    23.             hex[i++] = remainder + '0';
    24.         } else {
    25.             hex[i++] = remainder - 10 + 'A';
    26.         }
    27.         decimal /= 16;
    28.     }
    29.     for (int j = i - 1; j >= 0; j--) {
    30.         printf("%c", hex[j]);
    31.     }
    32.     printf("\n");
    33. }
    35. int main() {
    36.     int octal = 345;
    37.     int decimal = octalToDecimal(octal);
    38.     printf("八进制数 %d 转换为十六进制数是: ", octal);
    39.     decimalToHex(decimal);
    40.     return 0;
    41. }

    复制代码
    
    
  • 方法二（间接转换法）：先将八进制转二进制，再将二进制转十六进制。
    1. //  对于八进制数 345
    2. // 八进制转二进制
    3. // 3 对应 011，4 对应 100，5 对应 101
    4. // 二进制数为 011100101
    5. // 二进制转十六进制
    6. // 分组：0111 0010 1（高位补 0 后）。
    7. // 0111 对应 7，0010 对应 2，0001 对应 1。
    8. // 所以十六进制结果是 E5。

    复制代码
    1. #include <stdio.h>
    2. #include <string.h>
    4. // 八进制转二进制
    5. void octalToBinary(int octal) {
    6.     char binary[100] = "";
    7.     int index = 0;
    8.     while (octal > 0) {
    9.         int digit = octal % 10;
    10.         switch (digit) {
    11.             case 0: strcat(binary, "000"); break;
    12.             case 1: strcat(binary, "001"); break;
    13.             case 2: strcat(binary, "010"); break;
    14.             case 3: strcat(binary, "011"); break;
    15.             case 4: strcat(binary, "100"); break;
    16.             case 5: strcat(binary, "101"); break;
    17.             case 6: strcat(binary, "110"); break;
    18.             case 7: strcat(binary, "111"); break;
    19.         }
    20.         octal /= 10;
    21.     }
    22.     int len = strlen(binary);
    23.     for (int i = len - 1; i >= 0; i--) {
    24.         printf("%c", binary[i]);
    25.     }
    26.     printf("\n");
    27. }
    29. // 二进制转十六进制
    30. void binaryToHex(char *binary) {
    31.     int len = strlen(binary);
    32.     for (int i = len - 1; i >= 0; i -= 4) {
    33.         int group = 0;
    34.         int base = 1;
    35.         for (int j = 0; j < 4 && i - j >= 0; j++) {
    36.             group += (binary[i - j] - '0') * base;
    37.             base *= 2;
    38.         }
    39.         if (group < 10) {
    40.             printf("%d", group);
    41.         } else {
    42.             printf("%c", group - 10 + 'A');
    43.         }
    44.     }
    45.     printf("\n");
    46. }
    48. int main() {
    49.     int octal = 345;
    50.     printf("八进制数 %d 转换为十六进制数的过程：\n", octal);
    51.     octalToBinary(octal);
    52.     binaryToHex(octalToBinary(octal));
    53.     return 0;
    54. }

    复制代码
    
    
  
  
• 十六进制转八进制
  
  
  
  • 方法一：先将十六进制转十进制，再将十进制转八进制。
    1. 有十六进制数 A3
    3. 十六进制转十进制
    4. =10* 16^1+3*16^0
    5. =160+3
    6. =163(十进制)
    8. 十进制转八进制
    9. 163 ÷ 8 =20 ······3
    10. 20 ÷ 8 =2 ······4
    11. 2 ÷ 8 =0 ······2
    13. 所以八进制结果是 243

    复制代码
    1. #include <stdio.h>
    2. #include <math.h>
    4. // 十六进制转十进制
    5. int hexToDecimal(char *hex) {
    6.     int decimal = 0;
    7.     int len = strlen(hex);
    8.     for (int i = len - 1, power = 0; i >= 0; i--, power++) {
    9.         int value;
    10.         if (hex[i] >= '0' && hex[i] <= '9') {
    11.             value = hex[i] - '0';
    12.         } else if (hex[i] >= 'A' && hex[i] <= 'F') {
    13.             value = hex[i] - 'A' + 10;
    14.         } else if (hex[i] >= 'a' && hex[i] <= 'F') {
    15.             value = hex[i] - 'a' + 10;
    16.         }
    17.         decimal += value * pow(16, power);
    18.     }
    19.     return decimal;
    20. }
    22. // 十进制转八进制
    23. int decimalToOctal(int decimal) {
    24.     int octal = 0;
    25.     int i = 1;
    26.     while (decimal > 0) {
    27.         octal += (decimal % 8) * i;
    28.         decimal /= 8;
    29.         i *= 10;
    30.     }
    31.     return octal;
    32. }
    34. int main() {
    35.     char hex[] = "A3";
    36.     int decimal = hexToDecimal(hex);
    37.     int octal = decimalToOctal(decimal);
    38.     printf("十六进制数 %s 转换为八进制数是: %d\n", hex, octal);
    39.     return 0;
    40. }

    复制代码
    
    
  
  

---

追更

printf函数的应用

width应用

1. #include <stdio.h>
3. int main() {
4.     // 左对齐
5.     printf("左对齐: %-8d\n", 10);
7.     // 强制输出正负号
8.     printf("强制输出正负号: %+d\n", 10);
9.     printf("强制输出正负号: %+d\n", -10);
11.     // 正数前输出空格，负数前输出负号
12.     printf("正数前输出空格: % d\n", 10);
13.     printf("负数前输出负号: % d\n", -10);
15.     // 用 0 填充宽度
16.     printf("用 0 填充宽度: %08d\n", 10);
17.     printf("用 0 填充宽度: %08d\n", -10);
19.     // 对于 %o，输出八进制数时加前缀 0；对于 %x 或 %X，输出十六进制数时加前缀 0x 或 0X；
20.     // 对于 %f、%e 或 %g，即使没有小数部分也输出小数点
21.     printf("八进制加前缀: %#o\n", 10);
22.     printf("十六进制加前缀 (小写): %#x\n", 10);
23.     printf("十六进制加前缀 (大写): %#X\n", 10);
24.     printf("浮点数加小数点: %#f\n", 10.0);
25.     printf("浮点数加小数点: %#e\n", 10.0);
26.     printf("浮点数加小数点: %#g\n", 10.0);
28.     return 0;
29. }

复制代码

控制台打印

1. 左对齐: 10      
2. 强制输出正负号: +10
3. 强制输出正负号: -10
4. 正数前输出空格:  10
5. 负数前输出负号: -10
6. 用 0 填充宽度: 00000010
7. 用 0 填充宽度: -0000010
8. 八进制加前缀: 012
9. 十六进制加前缀 (小写): 0xa
10. 十六进制加前缀 (大写): 0XA
11. 浮点数加小数点: 10.000000
12. 浮点数加小数点: 1.000000e+01
13. 浮点数加小数点: 10.0000

复制代码

Flags应用

1. #include <stdio.h>
3. int main() {
4.     // 左对齐
5.     int num1 = 42;
6.     printf("左对齐: |%-8d|\n", num1);
8.     // 强制输出正负号
9.     int num2 = 33;
10.     int num3 = -25;
11.     printf("强制输出正负号 (正数): |%+d|\n", num2);
12.     printf("强制输出正负号 (负数): |%+d|\n", num3);
14.     // 正数前输出空格，负数前输出负号
15.     int num4 = 18;
16.     int num5 = -12;
17.     printf("正数前输出空格: |% d|\n", num4);
18.     printf("负数前输出负号: |% d|\n", num5);
20.     // 用 0 填充宽度
21.     int num6 = 7;
22.     int num7 = -49;
23.     printf("用 0 填充宽度 (正数): |%08d|\n", num6);
24.     printf("用 0 填充宽度 (负数): |%08d|\n", num7);
26.     // 对于 %o，输出八进制数时加前缀 0；对于 %x 或 %X，输出十六进制数时加前缀 0x 或 0X；对于 %f、%e 或 %g，即使没有小数部分也输出小数点
27.     int num8 = 20;
28.     float num9 = 123.0;
29.     printf("八进制加前缀: |%#o|\n", num8);
30.     printf("十六进制加前缀 (小写): |%#x|\n", num8);
31.     printf("十六进制加前缀 (大写): |%#X|\n", num8);
32.     printf("浮点数加小数点: |%#f|\n", num9);
33.     printf("浮点数加小数点 (科学计数法): |%#e|\n", num9);
34.     printf("浮点数加小数点 (自动选择格式): |%#g|\n", num9);
36.     return 0;
37. }

复制代码

1. 左对齐: |42      |
2. 强制输出正负号 (正数): |+33|
3. 强制输出正负号 (负数): |-25|
4. 正数前输出空格: | 18|
5. 负数前输出负号: |-12|
6. 用 0 填充宽度 (正数): |00000007|
7. 用 0 填充宽度 (负数): |-00000049|
8. 八进制加前缀: |024|
9. 十六进制加前缀 (小写): |0x14|
10. 十六进制加前缀 (大写): |0X14|
11. 浮点数加小数点: |123.000000|
12. 浮点数加小数点 (科学计数法): |1.230000e+02|
13. 浮点数加小数点 (自动选择格式): |123.000|

复制代码

Precision应用

1. #include <stdio.h>
3. int main() {
4.     // 对于浮点数，指定小数点后的位数
5.     float pi = 3.1415926;
6.     float euler = 2.7182818;
7.     printf("pi 保留两位小数: %.2f\n", pi);
8.     printf("euler 保留三位小数: %.3f\n", euler);
10.     // 对于字符串，指定最大输出长度
11.     char str[] = "Hello, World!";
12.     printf("字符串截取前 5 个字符: %.5s\n", str);
13.     printf("字符串截取前 8 个字符: %.8s\n", str);
15.     return 0;
16. }

复制代码

1. pi 保留两位小数: 3.14
2. euler 保留三位小数: 2.718
3. 字符串截取前 5 个字符: Hello
4. 字符串截取前 8 个字符: Hello, W

复制代码

Length 应用

1. #include <stdio.h>
3. int main() {
4.     // 使用 h 表示短整型
5.     short short_num = 10;
6.     printf("短整型: %hd\n", short_num);
8.     // 使用 l 表示长整型
9.     long long_num = 1000000L;
10.     printf("长整型: %ld\n", long_num);
12.     // 使用 l 表示双精度浮点数
13.     double double_num = 3.14;
14.     printf("双精度浮点数: %lf\n", double_num);
16.     // 使用 ll 表示长长整型
17.     long long long_long_num = 123456789012345LL;
18.     printf("长长整型: %lld\n", long_long_num);
20.     // 使用 L 表示长双精度浮点数
21.     long double long_double_num = 3.14L;
22.     printf("长双精度浮点数: %Lf\n", long_double_num);
24.     return 0;
25. }

复制代码

1. 短整型: 10
2. 长整型: 1000000
3. 双精度浮点数: 3.140000
4. 长长整型: 123456789012345
5. 长双精度浮点数: 3.140000

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。