上接《自己动手写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