自己动手写C语言格式化输出函数（二）

上接《自己动手写C语言格式化输出函数（一）》 。

三、格式化字符及字符串。

// 宽字符串转换ANSI字符串。参数：ANSI字符串，宽字符串，转换字符数(0不转换)。 // 返回实际转换字符个数 static INT WStrToStr(LPSTR dst, LPCWSTR src, INT count) { return WideCharToMultiByte(CP_THREAD_ACP, 0, src, -1, dst, count > 0? count + 1: 0, NULL, NULL) - 1; } // 格式化字符。参数：缓冲区，格式记录。返回缓冲区尾偏移 static LPSTR FormatCharA(LPSTR buffer, FormatRec *rec) { INT len, spaces; LPSTR p = buffer; if (rec->type == TYPE_LONG) { len = WStrToStr(NULL, (LPCWSTR)rec->param, 0); if (len == 0) len = sizeof(CHAR); } else len = sizeof(CHAR); spaces = rec->width - len; if (rec->left == FALSE && spaces > 0) { memset(p, CHAR_SPACE, spaces); p += spaces; } if (rec->type == TYPE_LONG) { WStrToStr(p, (LPCWSTR)rec->param, len); p += len; } else *p ++ = *(LPCSTR)rec->param; if (rec->left == TRUE && spaces > 0) { memset(p, CHAR_SPACE, spaces); p += spaces; } rec->param += rec->type == TYPE_LONG? TS_WCHAR : TS_CHAR; return p; } // 格式化字符串。参数：缓冲区，格式记录。返回缓冲区尾偏移 static LPSTR FormatStrA(LPSTR buffer, FormatRec *rec) { INT len, spaces; LPSTR p = buffer; if (rec->type == TYPE_LONG) len = WStrToStr(NULL, *(LPCWSTR*)rec->param, 0); else len = lstrlenA(*(LPCSTR*)rec->param); if (rec->precision >= 0 && len > rec->precision) len = rec->precision; spaces = rec->width - len; if (rec->left == FALSE && spaces > 0) { memset(p, CHAR_SPACE, spaces); p += spaces; } if (rec->type == TYPE_LONG) WStrToStr(p, *(LPCWSTR*)rec->param, len); else memcpy(p, *(LPCSTR*)rec->param, len); p += len; if (rec->left == TRUE && spaces > 0) { memset(p, CHAR_SPACE, spaces); p += spaces; } rec->param += TS_PTR; return p; }

如果不涉及宽字符，格式化字符和字符串是很简单的。

对于字符和字符串，"%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"。

四、格式化整型数。

// 格式化数字串。参数：缓冲区，格式记录，数字串，数字串长度。返回缓冲区尾偏移 static LPSTR FormatDigitsA(LPSTR buffer, FormatRec *rec, LPCSTR digits, INT len) { LPSTR p = buffer; INT spaces; if (rec->precision >= 0) rec->zero = FALSE; rec->precision -= len; if (rec->precision < 0) rec->precision = 0; spaces = rec->width - len - rec->precision; if (rec->negative) { spaces --; if (rec->left || rec->zero) *p ++ = (rec->negative == -1? CHAR_NEG : CHAR_POS); } if (rec->left == FALSE) { if (spaces > 0) { memset(p, rec->zero? CHAR_ZERO : CHAR_SPACE, spaces); p += spaces; } if (rec->negative && !rec->zero && !rec->decimals) *p ++ = (rec->negative == -1? CHAR_NEG : CHAR_POS); } if (rec->precision != 0) { memset(p, CHAR_ZERO, rec->precision); p += rec->precision; } memcpy(p, digits, len); p += len; if (rec->left == TRUE && spaces > 0) { memset(p, CHAR_SPACE, spaces); p += spaces; } return p; } // 整型数转换为数字串。参数：数字串，整型数，是否无符号整数 static INT IntToDigits(LPSTR digits, LONG src, BOOL *isUnsigned) { ULONG v; LPSTR p = digits + MAX_DIGITS_SIZE; if (*isUnsigned == FALSE && src < 0) src = -src; else *isUnsigned = TRUE; v = (ULONG)src; do { *(-- p) = (CHAR)(v % 10 + '0'); v /= 10; } while (v); return (INT)(MAX_DIGITS_SIZE - (p - digits)); } static INT LLongToDigits(LPSTR digits, LLONG src, BOOL *isUnsigned) { ULLONG v; LPSTR p = digits + MAX_DIGITS_SIZE; if (*isUnsigned == FALSE && src < 0) src = -src; else *isUnsigned = TRUE; v = (ULLONG)src; do { *(-- p) = (CHAR)(v % 10 + '0'); v /= 10; } while (v); return (INT)(MAX_DIGITS_SIZE - (p - digits)); } static INT numSizes[] = {sizeof(CHAR), sizeof(SHORT), sizeof(INT), sizeof(LONG), sizeof(LLONG)}; // 格式化整型数。参数：缓冲区，格式记录，是否无符号整数。返回缓冲区尾偏移 static LPSTR FormatIntA(LPSTR buffer, FormatRec *rec, BOOL isUnsigned) { ULONG value; INT len; CHAR digits[MAX_DIGITS_SIZE]; if (isUnsigned) rec->negative = 0; if (numSizes[rec->type] <= TS_PTR) { value = *(PULONG)rec->param; if (isUnsigned) value &= ((ULONG)(-1) >> ((TS_PTR - numSizes[rec->type]) << 3)); len = IntToDigits(digits, value, &isUnsigned); } else len = LLongToDigits(digits, *(PLLONG)rec->param, &isUnsigned); if (!isUnsigned) rec->negative = -1; rec->param += TypeSize(numSizes[rec->type]); rec->decimals = 0; return FormatDigitsA(buffer, rec, &digits[MAX_DIGITS_SIZE - len], len); }

在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）精度。

五、整型数格式化为十六进制和八进制数字串。

static CHAR hexDigitsU[] = "0123456789ABCDEF"; static CHAR hexDigitsL[] = "0123456789abcdef"; // 整型数转换为十六进制串。参数：十六进制串，整型数，字节长度，转换精度，是否大写 static INT NumberToHexA(LPSTR hex, LPCVOID lpNumber, INT bytes, INT precision, BOOL upper) { LPSTR ph = hex; LPBYTE pn = (LPBYTE)lpNumber; LPSTR hexDigits; INT len; for (bytes --; bytes > 0 && pn[bytes] == 0; bytes --); pn += bytes; bytes ++; len = bytes * 2; if ((*pn & 0xf0) == 0) len --; if (hex == NULL) return precision > len? precision : len; for (precision -= len; precision > 0; *ph ++ = '0', precision --); hexDigits = upper? hexDigitsU : hexDigitsL; if ((*pn & 0xf0) == 0) { *ph ++ = hexDigits[*pn -- & 0x0f]; bytes --; } for (; bytes > 0; bytes --, pn --) { *ph ++ = hexDigits[*pn >> 4]; *ph ++ = hexDigits[*pn & 0x0f]; } return (INT)(ph - hex); } // 按十六进制格式化整型数。参数：缓冲区，格式记录，类型字符(x or X) static LPSTR FormatHexA(LPSTR buffer, FormatRec *rec, CHAR hexChar) { LPSTR p = buffer; INT spaces, len, pix; BOOL upper = hexChar == 'X'; if (rec->precision >= 0) rec->zero = FALSE; pix = rec->decimals? 2 : 0; rec->precision -= pix; len = NumberToHexA(NULL, rec->param, numSizes[rec->type], rec->precision, upper); spaces = rec->width - len - pix; if (rec->decimals && (rec->left || rec->zero)) { memcpy(p, rec->decimals > 0? HEX_PREFIX_U : HEX_PREFIX_L, 2); p += 2; } if (rec->left == FALSE) { if (spaces > 0) { memset(p, rec->zero? CHAR_ZERO : CHAR_SPACE, spaces); p += spaces; } if (rec->decimals && !rec->zero) { memcpy(p, rec->decimals > 0? HEX_PREFIX_U : HEX_PREFIX_L, 2); p += 2; } } p += NumberToHexA(p, rec->param, numSizes[rec->type], rec->precision, upper); if (rec->left == TRUE && spaces > 0) { memset(p, CHAR_SPACE, spaces); p += spaces; } rec->param += TypeSize(numSizes[rec->type]); return p; } // 整型数转换为八进制串。参数：八进制串，整型数，字节长度 static INT NumberToOtcalA(LPSTR otcal, LPCVOID lpNumber, INT bytes) { LPSTR p = otcal + MAX_DIGITS_SIZE; ULLONG v = 0; memcpy(&v, lpNumber, bytes); do { *(-- p) = (CHAR)((v & 7) + '0'); v >>= 3; } while (v); return (INT)(MAX_DIGITS_SIZE - (p - otcal)); } // 按八进制格式化整型数。参数：缓冲区，格式记录 static LPSTR FormatOctalA(LPSTR buffer, FormatRec *rec) { CHAR otcal[MAX_DIGITS_SIZE]; INT len = NumberToOtcalA(otcal, rec->param, numSizes[rec->type]); rec->param += TypeSize(numSizes[rec->type]); rec->negative = 0; return FormatDigitsA(buffer, rec, &otcal[MAX_DIGITS_SIZE - len], len); }

整型数转换为十六进制或者八进制数字串，除了进制不同，其它与前面整型数转换为10进制数是一样的。

六、格式化指针。

// 按十六进制格式化指针。参数：缓冲区，格式记录 static LPSTR FormatPointerA(LPSTR buffer, FormatRec *rec) { INT prec = PTR_SIZE << 1; CHAR tmp[PTR_SIZE * 2]; NumberToHexA(tmp, rec->param, TS_PTR, prec, TRUE); rec->precision = -1; // 忽略精度 return FormatDigitsA(buffer, rec, tmp, prec); }

因为指针地址同样也是个整型数，所以指针的格式化和整型数转换为十六进制数字串是一样的，只不过精度是固定的，32位编译器下为8位十六进制数，64位编译器下则为16位十六进制数。

七、获取缓冲区当前位置字节数。

// 获取缓冲区当前位置字节数。参数：缓冲区，缓冲区首地址，格式记录 static VOID GetPosSizeA(LPSTR buffer, LPSTR buffer0, FormatRec *rec) { LLONG size = buffer - buffer0; memcpy((LPVOID)*(PLONG*)rec->param, &size, numSizes[rec->type]); rec->param += TS_PTR; }

这是格式化输出函数中最特殊的输出，它不是把某个参数的值输出到缓冲区，而是把输出缓冲区当前位置的长度输出到某个参数，这个参数必须是指针形式的。

同整型数转换为数字串一样，sprintfA确认的最小数据精度为sizeof(CHAR)，也可以改变为sizeof(SHORT)。

未完待续......

声明：本文代码主要供学习使用，如作其它用途，出问题慨不负责。

水平有限，错误在所难免，欢迎指正和指导。邮箱地址：maozefa@hotmail.com