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

`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);` 输出 `10`
`0`	用 0 填充宽度	`printf("%08d", 10);` 输出整数，宽度为 8，不足用 0 填充
`#`	对于 `%o`，输出八进制数时加前缀 `0`；对于 `%x` 或 `%X`，输出十六进制数时加前缀 `0x` 或 `0X`；对于 `%f`、`%e` 或 `%g`，即使没有小数部分也输出小数点	`printf("%#o", 10);` 输出 `012`

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

Width（宽度）

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

Precision（精度）

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

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

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);`	`10`	`int num;`
`%u`	无符号十进制整数	`scanf("%u", &num);`	`4294967295`	`unsigned int num;`
`%o`	八进制整数	`scanf("%o", &num);`	`12`	`int num;`
`%x` 或 `%X`	十六进制整数	`scanf("%x", &num);`<br>`scanf("%X", &num);`	`ff`<br>`FF`	`int num;`
`%f`	浮点数	`scanf("%f", &num);`	`3.14159`	`float num;`
`%e` 或 `%E`	科学计数法表示的浮点数	`scanf("%e", &num);`<br>`scanf("%E", &num);`	`3.141590e+00`<br>`3.141590E+00`	`float num;`
`%c`	单个字符	`scanf("%c", &ch);`	`A`	`char ch;`
`%s`	字符串	`scanf("%s", str);`	`Hello`	`char str[50];`

tips

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

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

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

使用 getchar 函数清除多余字符

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

二进制（Binary）

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

二进制转十进制

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

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

十进制转二进制

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

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

位运算符

按位与（`&`）

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

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

按位或（`|`）

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

#include <stdio.h>int main() {int a = 0b1010;int b = 0b1100;int result = a | b;  // 按位或printf("按位或结果: %d\n", result);  // 输出为 14，即 0b1110return 0;
}

按位异或（`^`）

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

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

按位取反（`~`）

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

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

左移（`<<`）

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

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

右移（`>>`）

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

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

二进制数的存储和表示

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

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

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

原码

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

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

反码

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

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

补码

补码是在反码的基础上加 1 得到的，它是计算机中最常用的表示有符号数的方式，因为使用补码可以方便地进行加减运算。

原码：10000000 00000000 00000000 00000101
反码：11111111 11111111 11111111 11111010
//直接加 1
11111111 11111111 11111111 11111010
+ 00000000 00000000 00000000 00000001
11111111 11111111 11111111 11111011//补码：11111111 11111111 11111111 11111011

为什么使用补码？

简化运算：使用补码可以将减法运算转换为加法运算，这样硬件只需要实现加法器就可以同时完成加法和减法运算。例如，对于 a - b，可以表示为 a + (-b)，而 -b 的补码可以通过 b 的补码取反加 1 得到。

// 要计算 3 - 5，在计算机中会将其转换为 3 + (-5)// 3 的原码和补码相同
原码：00000000 00000000 00000000 00000011
补码：00000000 00000000 00000000 00000011// -5 的原码
原码：10000000 00000000 00000000 00000101
反码：11111111 11111111 11111111 11111010
补码：11111111 11111111 11111111 11111011//计算 3 + (-5)
00000000 00000000 00000000 00000011  (3 的补码)
+ 11111111 11111111 11111111 11111011  (-5 的补码)
11111111 11111111 11111111 11111110
// 这是一个负数的补码
// 将其转换回原码来查看结果
// 先对补码取反加 1 得到原码// 补码：11111111 11111111 11111111 11111110
// 取反：10000000 00000000 00000000 00000001
// 加 1：10000000 00000000 00000000 00000010
// 所以结果是 -2，即 3 - 5 = -2。

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

总结

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

二进制数的应用

标志位操作

使用二进制的位来表示不同的标志。

#include <stdio.h>#define FLAG_A 0b0001
#define FLAG_B 0b0010
#define FLAG_C 0b0100int main() {int flags = 0;flags |= FLAG_A;  // 设置 FLAG_Aflags |= FLAG_B;  // 设置 FLAG_Bif (flags & FLAG_A) {printf("FLAG_A 已设置\n");}if (flags & FLAG_B) {printf("FLAG_B 已设置\n");}if (flags & FLAG_C) {printf("FLAG_C 已设置\n");}return 0;
}

位掩码

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

#include <stdio.h>int main() {int num = 0b10101010;int mask = 0b00110000;int result = num & mask;  // 提取特定的位printf("提取结果: %d\n", result);  // 输出为 0b00100000return 0;
}

八进制（Octal）

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

八进制转十进制

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

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

十进制转八进制

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

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

十进制（Decimal）

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

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

十六进制（Hexadecimal）

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

十六进制转十进制

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

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

十进制转十六进制

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

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

二进制与其他进制的转换

二进制转八进制

方法一：先将二进制转十进制，再将十进制转八进制。

// 假设我们有二进制数 101101// 二进制转十进制
1 * 2^5 + 0 * 2^4 + 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 1 * 2^0
=32 + 0 + 8 + 4 + 0 + 1
= 45（十进制）
// 十进制转八进制45 ÷ 8 = 5······5（余数）5 ÷ 8 = 0······5（余数）// 所以八进制的结果是55

#include <stdio.h>
#include <math.h>// 二进制转十进制
int binaryToDecimal(long long binary) {int decimal = 0;int power = 0;while (binary > 0) {decimal += (binary % 10) * pow(2, power);binary /= 10;power++;}return decimal;
}// 十进制转八进制
int decimalToOctal(int decimal) {int octal = 0;int i = 1;while (decimal > 0) {octal += (decimal % 8) * i;decimal /= 8;i *= 10;}return octal;
}int main() {long long binary = 101101;int decimal = binaryToDecimal(binary);int octal = decimalToOctal(decimal);printf("二进制数 %lld 转换为八进制数是: %d\n", binary, octal);return 0;
}

方法二（直接转换法）：从二进制数的小数点开始，向左（或向右）每三位一组划分（不够三位时，高位补0），然后将每组二进制数转换成对应的八进制数。

// 由于 2^3 = 8，所以可以将二进制数按三位一组划分，每组二进制数可以直接对应一个八进制数
// 对于二进制数 101101
// 分组：101 101（高位补 0 后）
// 101 对应八进制 5，101 对应八进制 5
// 八进制结果是 55。

#include <stdio.h>
#include <string.h>// 二进制转八进制
int binaryToOctalDirect(char *binary) {int octal = 0;int len = strlen(binary);int i = 0;while (i < len) {int group = 0;int base = 1;for (int j = 0; j < 3 && i < len; j++) {group += (binary[len - 1 - i] - '0') * base;base *= 2;i++;}octal = octal * 10 + group;}return octal;
}int main() {char binary[] = "101101";int octal = binaryToOctalDirect(binary);printf("二进制数 %s 转换为八进制数是: %d\n", binary, octal);return 0;
}

二进制转十六进制

方法一：先将二进制转十进制，再将十进制转十六进制。

// 假设我们有二进制数 1101101// 二进制转十进制1 * 2^6 + 1 * 2^5 + 0 * 2^4 + 1 * 2^3 + 1 * 2^2 + 0 * 2^1 + 1 * 2^0
=64 + 32 + 0 + 8 + 4 + 0 + 1
=109(十进制)// 十进制转十六进制
109 ÷ 16 =6······13（余数，用 D 表示）
6 ÷ 16 =0······6
// 十六进制结果是 6D

#include <stdio.h>
#include <math.h>// 二进制转十进制
int binaryToDecimal(long long binary) {int decimal = 0;int power = 0;while (binary > 0) {decimal += (binary % 10) * pow(2, power);binary /= 10;power++;}return decimal;
}// 十进制转十六进制
void decimalToHex(int decimal) {char hex[100];int i = 0;while (decimal > 0) {int remainder = decimal % 16;if (remainder < 10) {hex[i++] = remainder + '0';} else {hex[i++] = remainder - 10 + 'A';}decimal /= 16;}for (int j = i - 1; j >= 0; j--) {printf("%c", hex[j]);}printf("\n");
}int main() {long long binary = 1101101;int decimal = binaryToDecimal(binary);printf("二进制数 %lld 转换为十六进制数是: ", binary);decimalToHex(decimal);return 0;
}

方法二（直接转换法）：从二进制数的小数点开始，向左（或向右）每四位一组划分（不够四位时，高位补0），然后将每组二进制数转换成对应的十六进制数。

// 由于 2^4=16，所以可以将二进制数按四位一组划分，每组二进制数可以直接对应一个十六进制数// 对于二进制数 1101101分组：0110 1101（高位补 0 后）0110 对应十六进制 6，1101 对应十六进制 D。
所以十六进制结果是 6D。

#include <stdio.h>
#include <string.h>// 二进制转十六进制
void binaryToHexDirect(char *binary) {int len = strlen(binary);for (int i = len - 1; i >= 0; i -= 4) {int group = 0;int base = 1;for (int j = 0; j < 4 && i - j >= 0; j++) {group += (binary[i - j] - '0') * base;base *= 2;}if (group < 10) {printf("%d", group);} else {printf("%c", group - 10 + 'A');}}printf("\n");
}int main() {char binary[] = "1101101";printf("二进制数 %s 转换为十六进制数是: ", binary);binaryToHexDirect(binary);return 0;
}

八进制与十六进制的转换

八进制转十六进制

方法一：先将八进制转十进制，再将十进制转十六进制。

// 假设我们有八进制数 345。// 八进制转十进制
= 3 * 8^2 + 4 * 8^1 + 5 * 8^0
=192 + 32 +5
=229(十进制）十进制转十六进制229 ÷ 16 =14······ 5 （余数，用 5 表示）14 ÷ 16 =0······ 14  （余数，用 E 表示）//十六进制结果是 E5

#include <stdio.h>
#include <math.h>// 八进制转十进制
int octalToDecimal(int octal) {int decimal = 0;int power = 0;while (octal > 0) {decimal += (octal % 10) * pow(8, power);octal /= 10;power++;}return decimal;
}// 十进制转十六进制
void decimalToHex(int decimal) {char hex[100];int i = 0;while (decimal > 0) {int remainder = decimal % 16;if (remainder < 10) {hex[i++] = remainder + '0';} else {hex[i++] = remainder - 10 + 'A';}decimal /= 16;}for (int j = i - 1; j >= 0; j--) {printf("%c", hex[j]);}printf("\n");
}int main() {int octal = 345;int decimal = octalToDecimal(octal);printf("八进制数 %d 转换为十六进制数是: ", octal);decimalToHex(decimal);return 0;
}

方法二（间接转换法）：先将八进制转二进制，再将二进制转十六进制。

//  对于八进制数 345
// 八进制转二进制
// 3 对应 011，4 对应 100，5 对应 101
// 二进制数为 011100101
// 二进制转十六进制
// 分组：0111 0010 1（高位补 0 后）。
// 0111 对应 7，0010 对应 2，0001 对应 1。
// 所以十六进制结果是 E5。

#include <stdio.h>
#include <string.h>// 八进制转二进制
void octalToBinary(int octal) {char binary[100] = "";int index = 0;while (octal > 0) {int digit = octal % 10;switch (digit) {case 0: strcat(binary, "000"); break;case 1: strcat(binary, "001"); break;case 2: strcat(binary, "010"); break;case 3: strcat(binary, "011"); break;case 4: strcat(binary, "100"); break;case 5: strcat(binary, "101"); break;case 6: strcat(binary, "110"); break;case 7: strcat(binary, "111"); break;}octal /= 10;}int len = strlen(binary);for (int i = len - 1; i >= 0; i--) {printf("%c", binary[i]);}printf("\n");
}// 二进制转十六进制
void binaryToHex(char *binary) {int len = strlen(binary);for (int i = len - 1; i >= 0; i -= 4) {int group = 0;int base = 1;for (int j = 0; j < 4 && i - j >= 0; j++) {group += (binary[i - j] - '0') * base;base *= 2;}if (group < 10) {printf("%d", group);} else {printf("%c", group - 10 + 'A');}}printf("\n");
}int main() {int octal = 345;printf("八进制数 %d 转换为十六进制数的过程：\n", octal);octalToBinary(octal);binaryToHex(octalToBinary(octal));return 0;
}

十六进制转八进制

方法一：先将十六进制转十进制，再将十进制转八进制。

有十六进制数 A3十六进制转十进制
=10* 16^1+3*16^0
=160+3
=163(十进制)十进制转八进制
163 ÷ 8 =20 ······3
20 ÷ 8 =2 ······4
2 ÷ 8 =0 ······2所以八进制结果是 243

#include <stdio.h>
#include <math.h>// 十六进制转十进制
int hexToDecimal(char *hex) {int decimal = 0;int len = strlen(hex);for (int i = len - 1, power = 0; i >= 0; i--, power++) {int value;if (hex[i] >= '0' && hex[i] <= '9') {value = hex[i] - '0';} else if (hex[i] >= 'A' && hex[i] <= 'F') {value = hex[i] - 'A' + 10;} else if (hex[i] >= 'a' && hex[i] <= 'F') {value = hex[i] - 'a' + 10;}decimal += value * pow(16, power);}return decimal;
}// 十进制转八进制
int decimalToOctal(int decimal) {int octal = 0;int i = 1;while (decimal > 0) {octal += (decimal % 8) * i;decimal /= 8;i *= 10;}return octal;
}int main() {char hex[] = "A3";int decimal = hexToDecimal(hex);int octal = decimalToOctal(decimal);printf("十六进制数 %s 转换为八进制数是: %d\n", hex, octal);return 0;
}

追更

printf函数的应用

width应用

#include <stdio.h>int main() {// 左对齐printf("左对齐: %-8d\n", 10);// 强制输出正负号printf("强制输出正负号: %+d\n", 10);printf("强制输出正负号: %+d\n", -10);// 正数前输出空格，负数前输出负号printf("正数前输出空格: % d\n", 10);printf("负数前输出负号: % d\n", -10);// 用 0 填充宽度printf("用 0 填充宽度: %08d\n", 10);printf("用 0 填充宽度: %08d\n", -10);// 对于 %o，输出八进制数时加前缀 0；对于 %x 或 %X，输出十六进制数时加前缀 0x 或 0X；// 对于 %f、%e 或 %g，即使没有小数部分也输出小数点printf("八进制加前缀: %#o\n", 10);printf("十六进制加前缀 (小写): %#x\n", 10);printf("十六进制加前缀 (大写): %#X\n", 10);printf("浮点数加小数点: %#f\n", 10.0);printf("浮点数加小数点: %#e\n", 10.0);printf("浮点数加小数点: %#g\n", 10.0);return 0;
}

控制台打印

左对齐: 10      
强制输出正负号: +10
强制输出正负号: -10
正数前输出空格:  10
负数前输出负号: -10
用 0 填充宽度: 00000010
用 0 填充宽度: -0000010
八进制加前缀: 012
十六进制加前缀 (小写): 0xa
十六进制加前缀 (大写): 0XA
浮点数加小数点: 10.000000
浮点数加小数点: 1.000000e+01
浮点数加小数点: 10.0000

Flags应用

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

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

Precision应用

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

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

Length 应用

#include <stdio.h>int main() {// 使用 h 表示短整型short short_num = 10;printf("短整型: %hd\n", short_num);// 使用 l 表示长整型long long_num = 1000000L;printf("长整型: %ld\n", long_num);// 使用 l 表示双精度浮点数double double_num = 3.14;printf("双精度浮点数: %lf\n", double_num);// 使用 ll 表示长长整型long long long_long_num = 123456789012345LL;printf("长长整型: %lld\n", long_long_num);// 使用 L 表示长双精度浮点数long double long_double_num = 3.14L;printf("长双精度浮点数: %Lf\n", long_double_num);return 0;
}

短整型: 10
长整型: 1000000
双精度浮点数: 3.140000
长长整型: 123456789012345
长双精度浮点数: 3.140000