自己动手写C语言格式化输出函数（二）
上接《自己动手写C语言格式化输出函数（一）》 。
三、格式化字符及字符串。
1 // 宽字符串转换ANSI字符串。参数：ANSI字符串，宽字符串，转换字符数(0不转换)。
2 // 返回实际转换字符个数
3 static INT WStrToStr(LPSTR dst, LPCWSTR src, INT count)
4 {
5 return WideCharToMultiByte(CP_THREAD_ACP, 0, src, -1,
6 dst, count > 0? count + 1: 0, NULL, NULL) - 1;
7 }
8
9 // 格式化字符。参数：缓冲区，格式记录。返回缓冲区尾偏移
10 static LPSTR FormatCharA(LPSTR buffer, FormatRec *rec)
11 {
12 INT len, spaces;
13 LPSTR p = buffer;
14
15 if (rec->type == TYPE_LONG)
16 {
17 len = WStrToStr(NULL, (LPCWSTR)rec->param, 0);
18 if (len == 0) len = sizeof(CHAR);
19 }
20 else len = sizeof(CHAR);
21 spaces = rec->width - len;
22 if (rec->left == FALSE && spaces > 0)
23 {
24 memset(p, CHAR_SPACE, spaces);
25 p += spaces;
26 }
27 if (rec->type == TYPE_LONG)
28 {
29 WStrToStr(p, (LPCWSTR)rec->param, len);
30 p += len;
31 }
32 else *p ++ = *(LPCSTR)rec->param;
33 if (rec->left == TRUE && spaces > 0)
34 {
35 memset(p, CHAR_SPACE, spaces);
36 p += spaces;
37 }
38 rec->param += rec->type == TYPE_LONG? TS_WCHAR : TS_CHAR;
39 return p;
40 }
41
42 // 格式化字符串。参数：缓冲区，格式记录。返回缓冲区尾偏移
43 static LPSTR FormatStrA(LPSTR buffer, FormatRec *rec)
44 {
45 INT len, spaces;
46 LPSTR p = buffer;
47
48 if (rec->type == TYPE_LONG)
49 len = WStrToStr(NULL, *(LPCWSTR*)rec->param, 0);
50 else
51 len = lstrlenA(*(LPCSTR*)rec->param);
52 if (rec->precision >= 0 && len > rec->precision)
53 len = rec->precision;
54 spaces = rec->width - len;
55 if (rec->left == FALSE && spaces > 0)
56 {
57 memset(p, CHAR_SPACE, spaces);
58 p += spaces;
59 }
60 if (rec->type == TYPE_LONG)
61 WStrToStr(p, *(LPCWSTR*)rec->param, len);
62 else
63 memcpy(p, *(LPCSTR*)rec->param, len);
64 p += len;
65 if (rec->left == TRUE && spaces > 0)
66 {
67 memset(p, CHAR_SPACE, spaces);
68 p += spaces;
69 }
70 rec->param += TS_PTR;
71 return p;
72 }
2 // 返回实际转换字符个数
3 static INT WStrToStr(LPSTR dst, LPCWSTR src, INT count)
4 {
5 return WideCharToMultiByte(CP_THREAD_ACP, 0, src, -1,
6 dst, count > 0? count + 1: 0, NULL, NULL) - 1;
7 }
8
9 // 格式化字符。参数：缓冲区，格式记录。返回缓冲区尾偏移
10 static LPSTR FormatCharA(LPSTR buffer, FormatRec *rec)
11 {
12 INT len, spaces;
13 LPSTR p = buffer;
14
15 if (rec->type == TYPE_LONG)
16 {
17 len = WStrToStr(NULL, (LPCWSTR)rec->param, 0);
18 if (len == 0) len = sizeof(CHAR);
19 }
20 else len = sizeof(CHAR);
21 spaces = rec->width - len;
22 if (rec->left == FALSE && spaces > 0)
23 {
24 memset(p, CHAR_SPACE, spaces);
25 p += spaces;
26 }
27 if (rec->type == TYPE_LONG)
28 {
29 WStrToStr(p, (LPCWSTR)rec->param, len);
30 p += len;
31 }
32 else *p ++ = *(LPCSTR)rec->param;
33 if (rec->left == TRUE && spaces > 0)
34 {
35 memset(p, CHAR_SPACE, spaces);
36 p += spaces;
37 }
38 rec->param += rec->type == TYPE_LONG? TS_WCHAR : TS_CHAR;
39 return p;
40 }
41
42 // 格式化字符串。参数：缓冲区，格式记录。返回缓冲区尾偏移
43 static LPSTR FormatStrA(LPSTR buffer, FormatRec *rec)
44 {
45 INT len, spaces;
46 LPSTR p = buffer;
47
48 if (rec->type == TYPE_LONG)
49 len = WStrToStr(NULL, *(LPCWSTR*)rec->param, 0);
50 else
51 len = lstrlenA(*(LPCSTR*)rec->param);
52 if (rec->precision >= 0 && len > rec->precision)
53 len = rec->precision;
54 spaces = rec->width - len;
55 if (rec->left == FALSE && spaces > 0)
56 {
57 memset(p, CHAR_SPACE, spaces);
58 p += spaces;
59 }
60 if (rec->type == TYPE_LONG)
61 WStrToStr(p, *(LPCWSTR*)rec->param, len);
62 else
63 memcpy(p, *(LPCSTR*)rec->param, len);
64 p += len;
65 if (rec->left == TRUE && spaces > 0)
66 {
67 memset(p, CHAR_SPACE, spaces);
68 p += spaces;
69 }
70 rec->param += TS_PTR;
71 return p;
72 }
如果不涉及宽字符，格式化字符和字符串是很简单的。
对于字符和字符串，"%lc"和"%ls"表示宽字符和宽字符串，其它类型精度全部视为默认值，即ANSI字符和ANSI字符串。
宽字符的转换是由WStrToStr函数来完成的，而WStrToStr又是调用的Windows API函数WideCharToMultiByte，
在格式化字符0时，C语言的printf和sprintf有所不同，前者是用空格替代的。例如：printf("%s%c456", "123", 0)，显示出来是“123 456"，而sprintf(s, "%s%c456", "123", 0)后，s="123"，因此，sprintfA也就是s="123"。
四、格式化整型数。
1 // 格式化数字串。参数：缓冲区，格式记录，数字串，数字串长度。返回缓冲区尾偏移
2 static LPSTR FormatDigitsA(LPSTR buffer, FormatRec *rec, LPCSTR digits, INT len)
3 {
4 LPSTR p = buffer;
5 INT spaces;
6
7 if (rec->precision >= 0)
8 rec->zero = FALSE;
9 rec->precision -= len;
10 if (rec->precision < 0)
11 rec->precision = 0;
12 spaces = rec->width - len - rec->precision;
13 if (rec->negative)
14 {
15 spaces --;
16 if (rec->left || rec->zero)
17 *p ++ = (rec->negative == -1? CHAR_NEG : CHAR_POS);
18 }
19 if (rec->left == FALSE)
20 {
21 if (spaces > 0)
22 {
23 memset(p, rec->zero? CHAR_ZERO : CHAR_SPACE, spaces);
24 p += spaces;
25 }
26 if (rec->negative && !rec->zero && !rec->decimals)
27 *p ++ = (rec->negative == -1? CHAR_NEG : CHAR_POS);
28 }
29 if (rec->precision != 0)
30 {
31 memset(p, CHAR_ZERO, rec->precision);
32 p += rec->precision;
33 }
34 memcpy(p, digits, len);
35 p += len;
36 if (rec->left == TRUE && spaces > 0)
37 {
38 memset(p, CHAR_SPACE, spaces);
39 p += spaces;
40 }
41 return p;
42 }
43
44 // 整型数转换为数字串。参数：数字串，整型数，是否无符号整数
45
46 static INT IntToDigits(LPSTR digits, LONG src, BOOL *isUnsigned)
47 {
48 ULONG v;
49 LPSTR p = digits + MAX_DIGITS_SIZE;
50
51 if (*isUnsigned == FALSE && src < 0) src = -src;
52 else *isUnsigned = TRUE;
53 v = (ULONG)src;
54 do
55 {
56 *(-- p) = (CHAR)(v % 10 + '0');
57 v /= 10;
58 } while (v);
59 return (INT)(MAX_DIGITS_SIZE - (p - digits));
60 }
61
62 static INT LLongToDigits(LPSTR digits, LLONG src, BOOL *isUnsigned)
63 {
64 ULLONG v;
65 LPSTR p = digits + MAX_DIGITS_SIZE;
66
67 if (*isUnsigned == FALSE && src < 0) src = -src;
68 else *isUnsigned = TRUE;
69 v = (ULLONG)src;
70 do
71 {
72 *(-- p) = (CHAR)(v % 10 + '0');
73 v /= 10;
74 } while (v);
75 return (INT)(MAX_DIGITS_SIZE - (p - digits));
76 }
77
78 static INT numSizes[] = {sizeof(CHAR), sizeof(SHORT), sizeof(INT), sizeof(LONG), sizeof(LLONG)};
79
80 // 格式化整型数。参数：缓冲区，格式记录，是否无符号整数。返回缓冲区尾偏移
81 static LPSTR FormatIntA(LPSTR buffer, FormatRec *rec, BOOL isUnsigned)
82 {
83 ULONG value;
84 INT len;
85 CHAR digits[MAX_DIGITS_SIZE];
86
87 if (isUnsigned) rec->negative = 0;
88 if (numSizes[rec->type] <= TS_PTR)
89 {
90 value = *(PULONG)rec->param;
91 if (isUnsigned)
92 value &= ((ULONG)(-1) >> ((TS_PTR - numSizes[rec->type]) << 3));
93 len = IntToDigits(digits, value, &isUnsigned);
94 }
95 else
96 len = LLongToDigits(digits, *(PLLONG)rec->param, &isUnsigned);
97 if (!isUnsigned) rec->negative = -1;
98 rec->param += TypeSize(numSizes[rec->type]);
99 rec->decimals = 0;
100 return FormatDigitsA(buffer, rec, &digits[MAX_DIGITS_SIZE - len], len);
101 }
2 static LPSTR FormatDigitsA(LPSTR buffer, FormatRec *rec, LPCSTR digits, INT len)
3 {
4 LPSTR p = buffer;
5 INT spaces;
6
7 if (rec->precision >= 0)
8 rec->zero = FALSE;
9 rec->precision -= len;
10 if (rec->precision < 0)
11 rec->precision = 0;
12 spaces = rec->width - len - rec->precision;
13 if (rec->negative)
14 {
15 spaces --;
16 if (rec->left || rec->zero)
17 *p ++ = (rec->negative == -1? CHAR_NEG : CHAR_POS);
18 }
19 if (rec->left == FALSE)
20 {
21 if (spaces > 0)
22 {
23 memset(p, rec->zero? CHAR_ZERO : CHAR_SPACE, spaces);
24 p += spaces;
25 }
26 if (rec->negative && !rec->zero && !rec->decimals)
27 *p ++ = (rec->negative == -1? CHAR_NEG : CHAR_POS);
28 }
29 if (rec->precision != 0)
30 {
31 memset(p, CHAR_ZERO, rec->precision);
32 p += rec->precision;
33 }
34 memcpy(p, digits, len);
35 p += len;
36 if (rec->left == TRUE && spaces > 0)
37 {
38 memset(p, CHAR_SPACE, spaces);
39 p += spaces;
40 }
41 return p;
42 }
43
44 // 整型数转换为数字串。参数：数字串，整型数，是否无符号整数
45
46 static INT IntToDigits(LPSTR digits, LONG src, BOOL *isUnsigned)
47 {
48 ULONG v;
49 LPSTR p = digits + MAX_DIGITS_SIZE;
50
51 if (*isUnsigned == FALSE && src < 0) src = -src;
52 else *isUnsigned = TRUE;
53 v = (ULONG)src;
54 do
55 {
56 *(-- p) = (CHAR)(v % 10 + '0');
57 v /= 10;
58 } while (v);
59 return (INT)(MAX_DIGITS_SIZE - (p - digits));
60 }
61
62 static INT LLongToDigits(LPSTR digits, LLONG src, BOOL *isUnsigned)
63 {
64 ULLONG v;
65 LPSTR p = digits + MAX_DIGITS_SIZE;
66
67 if (*isUnsigned == FALSE && src < 0) src = -src;
68 else *isUnsigned = TRUE;
69 v = (ULLONG)src;
70 do
71 {
72 *(-- p) = (CHAR)(v % 10 + '0');
73 v /= 10;
74 } while (v);
75 return (INT)(MAX_DIGITS_SIZE - (p - digits));
76 }
77
78 static INT numSizes[] = {sizeof(CHAR), sizeof(SHORT), sizeof(INT), sizeof(LONG), sizeof(LLONG)};
79
80 // 格式化整型数。参数：缓冲区，格式记录，是否无符号整数。返回缓冲区尾偏移
81 static LPSTR FormatIntA(LPSTR buffer, FormatRec *rec, BOOL isUnsigned)
82 {
83 ULONG value;
84 INT len;
85 CHAR digits[MAX_DIGITS_SIZE];
86
87 if (isUnsigned) rec->negative = 0;
88 if (numSizes[rec->type] <= TS_PTR)
89 {
90 value = *(PULONG)rec->param;
91 if (isUnsigned)
92 value &= ((ULONG)(-1) >> ((TS_PTR - numSizes[rec->type]) << 3));
93 len = IntToDigits(digits, value, &isUnsigned);
94 }
95 else
96 len = LLongToDigits(digits, *(PLLONG)rec->param, &isUnsigned);
97 if (!isUnsigned) rec->negative = -1;
98 rec->param += TypeSize(numSizes[rec->type]);
99 rec->decimals = 0;
100 return FormatDigitsA(buffer, rec, &digits[MAX_DIGITS_SIZE - len], len);
101 }
在C的基本数据中，整型数的表达范围是最“与时俱进”的。16位编译器时，int是2字节，long为4字节；而32编译器下，int和long都变成了4字节，另外多了个8字节的_int64类型；64位编译器下，int仍然是4字节，long成了8字节，是否会有个16字节的_int128？我没用过64位编译器，不知道。代码中定义了一个LLONG类型，并写了2个整型数转换字符串函数，凡是小于或等于指针长度范围的整型数，使用IntToDigits函数，否则使用LLongToDigits函数。从表面看，这2个函数除数据类型不同外，语句是一样的，但编译后，前者的速度要快。如果是写商用的函数，建议还是使用插入汇编进行转换，因为汇编只作一个除法，就可的到商和余数，而高级语言需作2个除法。
有些C语言格式化输出函数在整型数转换时，是忽略hh（或者H）精度的，也就是说整型数转换的最小精度为sizeof(SHORT)，而sprintfA的整型数的最小精度为sizeof(CHAR)。比如"%hhu", -123，前者输出是65413，而后者却是133。如果把代码中numSizes数组的第一个元素改为sizeof(SHORT)，sprintfA也会忽略hh（或者H）精度。
五、整型数格式化为十六进制和八进制数字串。
1 static CHAR hexDigitsU[] = "0123456789ABCDEF";
2 static CHAR hexDigitsL[] = "0123456789abcdef";
3
4 // 整型数转换为十六进制串。参数：十六进制串，整型数，字节长度，转换精度，是否大写
5 static INT NumberToHexA(LPSTR hex, LPCVOID lpNumber, INT bytes, INT precision, BOOL upper)
6 {
7 LPSTR ph = hex;
8 LPBYTE pn = (LPBYTE)lpNumber;
9 LPSTR hexDigits;
10 INT len;
11
12 for (bytes --; bytes > 0 && pn[bytes] == 0; bytes --);
13 pn += bytes;
14 bytes ++;
15 len = bytes * 2;
16 if ((*pn & 0xf0) == 0) len --;
17 if (hex == NULL)
18 return precision > len? precision : len;
19 for (precision -= len; precision > 0; *ph ++ = '0', precision --);
20 hexDigits = upper? hexDigitsU : hexDigitsL;
21 if ((*pn & 0xf0) == 0)
22 {
23 *ph ++ = hexDigits[*pn -- & 0x0f];
24 bytes --;
25 }
26 for (; bytes > 0; bytes --, pn --)
27 {
28 *ph ++ = hexDigits[*pn >> 4];
29 *ph ++ = hexDigits[*pn & 0x0f];
30 }
31 return (INT)(ph - hex);
32 }
33
34 // 按十六进制格式化整型数。参数：缓冲区，格式记录，类型字符(x or X)
35 static LPSTR FormatHexA(LPSTR buffer, FormatRec *rec, CHAR hexChar)
36 {
37 LPSTR p = buffer;
38 INT spaces, len, pix;
39 BOOL upper = hexChar == 'X';
40 if (rec->precision >= 0)
41 rec->zero = FALSE;
42 pix = rec->decimals? 2 : 0;
43 rec->precision -= pix;
44 len = NumberToHexA(NULL, rec->param, numSizes[rec->type], rec->precision, upper);
45 spaces = rec->width - len - pix;
46 if (rec->decimals && (rec->left || rec->zero))
47 {
48 memcpy(p, rec->decimals > 0? HEX_PREFIX_U : HEX_PREFIX_L, 2);
49 p += 2;
50 }
51 if (rec->left == FALSE)
52 {
53 if (spaces > 0)
54 {
55 memset(p, rec->zero? CHAR_ZERO : CHAR_SPACE, spaces);
56 p += spaces;
57 }
58 if (rec->decimals && !rec->zero)
59 {
60 memcpy(p, rec->decimals > 0? HEX_PREFIX_U : HEX_PREFIX_L, 2);
61 p += 2;
62 }
63 }
64 p += NumberToHexA(p, rec->param, numSizes[rec->type], rec->precision, upper);
65 if (rec->left == TRUE && spaces > 0)
66 {
67 memset(p, CHAR_SPACE, spaces);
68 p += spaces;
69 }
70 rec->param += TypeSize(numSizes[rec->type]);
71 return p;
72 }
73
74 // 整型数转换为八进制串。参数：八进制串，整型数，字节长度
75 static INT NumberToOtcalA(LPSTR otcal, LPCVOID lpNumber, INT bytes)
76 {
77 LPSTR p = otcal + MAX_DIGITS_SIZE;
78 ULLONG v = 0;
79 memcpy(&v, lpNumber, bytes);
80 do
81 {
82 *(-- p) = (CHAR)((v & 7) + '0');
83 v >>= 3;
84 } while (v);
85 return (INT)(MAX_DIGITS_SIZE - (p - otcal));
86 }
87
88 // 按八进制格式化整型数。参数：缓冲区，格式记录
89 static LPSTR FormatOctalA(LPSTR buffer, FormatRec *rec)
90 {
91 CHAR otcal[MAX_DIGITS_SIZE];
92 INT len = NumberToOtcalA(otcal, rec->param, numSizes[rec->type]);
93 rec->param += TypeSize(numSizes[rec->type]);
94 rec->negative = 0;
95 return FormatDigitsA(buffer, rec, &otcal[MAX_DIGITS_SIZE - len], len);
96 }
2 static CHAR hexDigitsL[] = "0123456789abcdef";
3
4 // 整型数转换为十六进制串。参数：十六进制串，整型数，字节长度，转换精度，是否大写
5 static INT NumberToHexA(LPSTR hex, LPCVOID lpNumber, INT bytes, INT precision, BOOL upper)
6 {
7 LPSTR ph = hex;
8 LPBYTE pn = (LPBYTE)lpNumber;
9 LPSTR hexDigits;
10 INT len;
11
12 for (bytes --; bytes > 0 && pn[bytes] == 0; bytes --);
13 pn += bytes;
14 bytes ++;
15 len = bytes * 2;
16 if ((*pn & 0xf0) == 0) len --;
17 if (hex == NULL)
18 return precision > len? precision : len;
19 for (precision -= len; precision > 0; *ph ++ = '0', precision --);
20 hexDigits = upper? hexDigitsU : hexDigitsL;
21 if ((*pn & 0xf0) == 0)
22 {
23 *ph ++ = hexDigits[*pn -- & 0x0f];
24 bytes --;
25 }
26 for (; bytes > 0; bytes --, pn --)
27 {
28 *ph ++ = hexDigits[*pn >> 4];
29 *ph ++ = hexDigits[*pn & 0x0f];
30 }
31 return (INT)(ph - hex);
32 }
33
34 // 按十六进制格式化整型数。参数：缓冲区，格式记录，类型字符(x or X)
35 static LPSTR FormatHexA(LPSTR buffer, FormatRec *rec, CHAR hexChar)
36 {
37 LPSTR p = buffer;
38 INT spaces, len, pix;
39 BOOL upper = hexChar == 'X';
40 if (rec->precision >= 0)
41 rec->zero = FALSE;
42 pix = rec->decimals? 2 : 0;
43 rec->precision -= pix;
44 len = NumberToHexA(NULL, rec->param, numSizes[rec->type], rec->precision, upper);
45 spaces = rec->width - len - pix;
46 if (rec->decimals && (rec->left || rec->zero))
47 {
48 memcpy(p, rec->decimals > 0? HEX_PREFIX_U : HEX_PREFIX_L, 2);
49 p += 2;
50 }
51 if (rec->left == FALSE)
52 {
53 if (spaces > 0)
54 {
55 memset(p, rec->zero? CHAR_ZERO : CHAR_SPACE, spaces);
56 p += spaces;
57 }
58 if (rec->decimals && !rec->zero)
59 {
60 memcpy(p, rec->decimals > 0? HEX_PREFIX_U : HEX_PREFIX_L, 2);
61 p += 2;
62 }
63 }
64 p += NumberToHexA(p, rec->param, numSizes[rec->type], rec->precision, upper);
65 if (rec->left == TRUE && spaces > 0)
66 {
67 memset(p, CHAR_SPACE, spaces);
68 p += spaces;
69 }
70 rec->param += TypeSize(numSizes[rec->type]);
71 return p;
72 }
73
74 // 整型数转换为八进制串。参数：八进制串，整型数，字节长度
75 static INT NumberToOtcalA(LPSTR otcal, LPCVOID lpNumber, INT bytes)
76 {
77 LPSTR p = otcal + MAX_DIGITS_SIZE;
78 ULLONG v = 0;
79 memcpy(&v, lpNumber, bytes);
80 do
81 {
82 *(-- p) = (CHAR)((v & 7) + '0');
83 v >>= 3;
84 } while (v);
85 return (INT)(MAX_DIGITS_SIZE - (p - otcal));
86 }
87
88 // 按八进制格式化整型数。参数：缓冲区，格式记录
89 static LPSTR FormatOctalA(LPSTR buffer, FormatRec *rec)
90 {
91 CHAR otcal[MAX_DIGITS_SIZE];
92 INT len = NumberToOtcalA(otcal, rec->param, numSizes[rec->type]);
93 rec->param += TypeSize(numSizes[rec->type]);
94 rec->negative = 0;
95 return FormatDigitsA(buffer, rec, &otcal[MAX_DIGITS_SIZE - len], len);
96 }
整型数转换为十六进制或者八进制数字串，除了进制不同，其它与前面整型数转换为10进制数是一样的。
六、格式化指针。
1 // 按十六进制格式化指针。参数：缓冲区，格式记录
2 static LPSTR FormatPointerA(LPSTR buffer, FormatRec *rec)
3 {
4 INT prec = PTR_SIZE << 1;
5 CHAR tmp[PTR_SIZE * 2];
6
7 NumberToHexA(tmp, rec->param, TS_PTR, prec, TRUE);
8 rec->precision = -1; // 忽略精度
9 return FormatDigitsA(buffer, rec, tmp, prec);
10 }
2 static LPSTR FormatPointerA(LPSTR buffer, FormatRec *rec)
3 {
4 INT prec = PTR_SIZE << 1;
5 CHAR tmp[PTR_SIZE * 2];
6
7 NumberToHexA(tmp, rec->param, TS_PTR, prec, TRUE);
8 rec->precision = -1; // 忽略精度
9 return FormatDigitsA(buffer, rec, tmp, prec);
10 }
因为指针地址同样也是个整型数，所以指针的格式化和整型数转换为十六进制数字串是一样的，只不过精度是固定的，32位编译器下为8位十六进制数，64位编译器下则为16位十六进制数。
七、获取缓冲区当前位置字节数。
1 // 获取缓冲区当前位置字节数。参数：缓冲区，缓冲区首地址，格式记录
2 static VOID GetPosSizeA(LPSTR buffer, LPSTR buffer0, FormatRec *rec)
3 {
4 LLONG size = buffer - buffer0;
5 memcpy((LPVOID)*(PLONG*)rec->param, &size, numSizes[rec->type]);
6 rec->param += TS_PTR;
7 }
2 static VOID GetPosSizeA(LPSTR buffer, LPSTR buffer0, FormatRec *rec)
3 {
4 LLONG size = buffer - buffer0;
5 memcpy((LPVOID)*(PLONG*)rec->param, &size, numSizes[rec->type]);
6 rec->param += TS_PTR;
7 }
这是格式化输出函数中最特殊的输出，它不是把某个参数的值输出到缓冲区，而是把输出缓冲区当前位置的长度输出到某个参数，这个参数必须是指针形式的。
同整型数转换为数字串一样，sprintfA确认的最小数据精度为sizeof(CHAR)，也可以改变为sizeof(SHORT)。
未完待续......
声明：本文代码主要供学习使用，如作其它用途，出问题慨不负责。
水平有限，错误在所难免，欢迎指正和指导。邮箱地址：maozefa@hotmail.com
