自己动手写C语言浮点数转换字符串函数

前几天，应一个小友要求，写了几个字符串转换函数帮助其进行语言学习，自觉其中的几个函数还比较满意，故发布在此，可供初学者参考。

浮点数转换字符串函数说简单也简单，说麻烦，也够烦心的，关键看你如何写了。简单点的几十行代码就行，复杂点的恐怕就的几百行代码了。如果还要考虑移植性、可读性甚至可维护性等就更麻烦的了。我一贯认为，一些事务性的项目应着重考虑移植性、可读性和可维护性等，而常用的带点系统性质的函数代码就应该以执行效率为主。

本文的浮点数转换字符串函数还是比较复杂的，基本可算得上较低层次的转换。由于我已经习惯了用BCB写C/C++代码，因此我写的浮点数转换字符串函数是80位扩展精度浮点数的，但那个小友拿回去试了一下，说他用的VC不支持80位扩展精度浮点数，虽然能定义long double变量，但实际上还是64位的，我只好又重写了一个64位双精度浮点数的，2个版本使用条件编译，这也算得上是移植性吧，呵呵。

下面是浮点数转换字符串函数的全部代码：

#define	USE_EXTENDED

/***************************************************************************
* 定义浮点数转换字符串结构                                                 *
***************************************************************************/
typedef struct
{
	SHORT	exponent;	/* 指数（整数位数） */
	BYTE	negative;	/* 负数（0正，1负）*/
	CHAR	digits[21];	/* 十进制整数字串 */
}FloatRec;

#define	F_DEFDECIMALS	6
#define	F_MAXDECIMALS	100

#ifdef	USE_EXTENDED

#define	F_MAXPRECISION	19
#define	F_CONEXPONENT	0x3fff

typedef long double			EXTENDED, *PExtended, *PEXTENDED;

#include <pshpack2.h>

typedef struct
{
	UINT64 mantissa;
	USHORT exponent;
}_Extended;

#include <poppack.h>

static CONST _Extended _tab0[] =
{
	{0x8000000000000000, 0x3FFF},	/* 10**0 */
	{0xA000000000000000, 0x4002},	/* 10**1 */
	{0xC800000000000000, 0x4005},	/* 10**2 */
	{0xFA00000000000000, 0x4008},	/* 10**3 */
	{0x9C40000000000000, 0x400C},	/* 10**4 */
	{0xC350000000000000, 0x400F},	/* 10**5 */
	{0xF424000000000000, 0x4012},	/* 10**6 */
	{0x9896800000000000, 0x4016},	/* 10**7 */
	{0xBEBC200000000000, 0x4019},	/* 10**8 */
	{0xEE6B280000000000, 0x401C},	/* 10**9 */
	{0x9502F90000000000, 0x4020},	/* 10**10 */
	{0xBA43B74000000000, 0x4023},	/* 10**11 */
	{0xE8D4A51000000000, 0x4026},	/* 10**12 */
	{0x9184E72A00000000, 0x402A},	/* 10**13 */
	{0xB5E620F480000000, 0x402D},	/* 10**14 */
	{0xE35FA931A0000000, 0x4030},	/* 10**15 */
	{0x8E1BC9BF04000000, 0x4034},	/* 10**16 */
	{0xB1A2BC2EC5000000, 0x4037},	/* 10**17 */
	{0xDE0B6B3A76400000, 0x403A},	/* 10**18 */
	{0x8AC7230489E80000, 0x403E},	/* 10**19 */
	{0xAD78EBC5AC620000, 0x4041},	/* 10**20 */
	{0xD8D726B7177A8000, 0x4044},	/* 10**21 */
	{0x878678326EAC9000, 0x4048},	/* 10**22 */
	{0xA968163F0A57B400, 0x404B},	/* 10**23 */
	{0xD3C21BCECCEDA100, 0x404E},	/* 10**24 */
	{0x84595161401484A0, 0x4052},	/* 10**25 */
	{0xA56FA5B99019A5C8, 0x4055},	/* 10**26 */
	{0xCECB8F27F4200F3A, 0x4058},	/* 10**27 */
	{0x813F3978F8940984, 0x405C},	/* 10**28 */
	{0xA18F07D736B90BE5, 0x405F},	/* 10**29 */
	{0xC9F2C9CD04674EDF, 0x4062},	/* 10**30 */
	{0xFC6F7C4045812296, 0x4065}	/* 10**31 */
};

static CONST _Extended _tab1[] =
{
	{0x9DC5ADA82B70B59E, 0x4069},	/* 10**32 */
	{0xC2781F49FFCFA6D5, 0x40D3},	/* 10**64 */
	{0xEFB3AB16C59B14A3, 0x413D},	/* 10**96 */
	{0x93BA47C980E98CE0, 0x41A8},	/* 10**128 */
	{0xB616A12B7FE617AA, 0x4212},	/* 10**160 */
	{0xE070F78D3927556B, 0x427C},	/* 10**192 */
	{0x8A5296FFE33CC930, 0x42E7},	/* 10**224 */
	{0xAA7EEBFB9DF9DE8E, 0x4351},	/* 10**256 */
	{0xD226FC195C6A2F8C, 0x43BB},	/* 10**288 */
	{0x81842F29F2CCE376, 0x4426},	/* 10**320 */
	{0x9FA42700DB900AD2, 0x4490},	/* 10**352 */
	{0xC4C5E310AEF8AA17, 0x44FA},	/* 10**384 */
	{0xF28A9C07E9B09C59, 0x4564},	/* 10**416 */
	{0x957A4AE1EBF7F3D4, 0x45CF},	/* 10**448 */
	{0xB83ED8DC0795A262, 0x4639}	/* 10**480 */
};

static CONST _Extended _tab2[] =
{
	{0xE319A0AEA60E91C7, 0x46A3},	/* 10**512 */
	{0xC976758681750C17, 0x4D48},	/* 10**1024 */
	{0xB2B8353B3993A7E4, 0x53ED},	/* 10**1536 */
	{0x9E8B3B5DC53D5DE5, 0x5A92},	/* 10**2048 */
	{0x8CA554C020A1F0A6, 0x6137},	/* 10**2560 */
	{0xF9895D25D88B5A8B, 0x67DB},	/* 10**3072 */
	{0xDD5DC8A2BF27F3F8, 0x6E80},	/* 10**3584 */
	{0xC46052028A20979B, 0x7525},	/* 10**4096 */
	{0xAE3511626ED559F0, 0x7BCA}	/* 10**4608 */
};

static CONST EXTENDED _conPrec = 1E19;

#else	// USE_EXTENDED

#define	F_MAXPRECISION	17
#define	F_CONEXPONENT	0x03ff

typedef double		EXTENDED, *PExtended, *PEXTENDED;

static CONST UINT64 _tab0[] =
{
	{0x3FF0000000000000},	/* 10**0 */
	{0x4024000000000000},	/* 10**1 */
	{0x4059000000000000},	/* 10**2 */
	{0x408F400000000000},	/* 10**3 */
	{0x40C3880000000000},	/* 10**4 */
	{0x40F86A0000000000},	/* 10**5 */
	{0x412E848000000000},	/* 10**6 */
	{0x416312D000000000},	/* 10**7 */
	{0x4197D78400000000},	/* 10**8 */
	{0x41CDCD6500000000},	/* 10**9 */
	{0x4202A05F20000000},	/* 10**10 */
	{0x42374876E8000000},	/* 10**11 */
	{0x426D1A94A2000000},	/* 10**12 */
	{0x42A2309CE5400000},	/* 10**13 */
	{0x42D6BCC41E900000},	/* 10**14 */
	{0x430C6BF526340000},	/* 10**15 */
	{0x4341C37937E08000},	/* 10**16 */
	{0x4376345785D8A000},	/* 10**17 */
	{0x43ABC16D674EC800},	/* 10**18 */
	{0x43E158E460913D00},	/* 10**19 */
	{0x4415AF1D78B58C40},	/* 10**20 */
	{0x444B1AE4D6E2EF50},	/* 10**21 */
	{0x4480F0CF064DD592},	/* 10**22 */
	{0x44B52D02C7E14AF7},	/* 10**23 */
	{0x44EA784379D99DB4},	/* 10**24 */
	{0x45208B2A2C280291},	/* 10**25 */
	{0x4554ADF4B7320335},	/* 10**26 */
	{0x4589D971E4FE8402},	/* 10**27 */
	{0x45C027E72F1F1281},	/* 10**28 */
	{0x45F431E0FAE6D722},	/* 10**29 */
	{0x46293E5939A08CEA},	/* 10**30 */
	{0x465F8DEF8808B024}	/* 10**31 */
};

static CONST UINT64 _tab1[] =
{
	{0x4693B8B5B5056E17},	/* 10**32 */
	{0x4D384F03E93FF9F5},	/* 10**64 */
	{0x53DDF67562D8B363},	/* 10**96 */
	{0x5A827748F9301D32},	/* 10**128 */
	{0x6126C2D4256FFCC3},	/* 10**160 */
	{0x67CC0E1EF1A724EB},	/* 10**192 */
	{0x6E714A52DFFC679A},	/* 10**224 */
	{0x75154FDD7F73BF3C},	/* 10**256 */
	{0x7BBA44DF832B8D46},	/* 10**288 */
};

static CONST EXTENDED _conPrec = 1E17;

#endif		// !USE_EXTENDED

static CONST UINT64 _cvttab[F_MAXPRECISION] =
{
#ifdef	USE_EXTENDED
	0xDE0B6B3A7640000, 0x16345785D8A0000, 
#endif
	0x02386F26FC10000, 0x0038D7EA4C68000, 0x0005AF3107A4000, 0x00009184E72A000,
	0x00000E8D4A51000, 0x00000174876E800, 0x0000002540BE400, 0x00000003B9ACA00,
	0x000000005F5E100, 0x000000000989680, 0x0000000000F4240, 0x0000000000186A0,
	0x000000000002710, 0x0000000000003E8, 0x000000000000064, 0x00000000000000A,
	0x000000000000001
};

#define	DECIMAL_EXP(exponent)	((((exponent - F_CONEXPONENT) * 0x4d10) >> 16) + 1)

static VOID AdjFloatDigits(UINT64 value, INT precision, INT decimals, FloatRec *rec)
{
	INT i;
	// value是F_MAXPRECISION位十进制整数，故从最高位开始转换为数字串
	for (i = 0; value; i ++)
	{
		rec->digits[i] = (CHAR)((value / _cvttab[i]) | 0x30);
		value %= _cvttab[i];
	}
	memset(rec->digits + i, 0, F_MAXPRECISION - i);
	// 下面对数字串作精度处理
	// 如果总的精度小于0，数字串为空串，该数字转换为'0'
	if ((i = (rec->exponent + decimals)) < 0)
	{
		rec->exponent = rec->negative = rec->digits[0] = 0;
		return;
	}
	if (i > precision) i = precision;
	// 如果精度位数小于18，同时该位大于等于'5'，四舍五入
	if (i < F_MAXPRECISION && rec->digits[i] >= '5')
	{
		do
		{
			rec->digits[i --] = 0;
			rec->digits[i] ++;
		}while (i >= 0 && rec->digits[i] > '9');
		if (i < 0)
		{
			rec->digits[0] = '1';
			rec->exponent ++;
		}
	}
	// 否则，去掉数字串尾部多余的'0'
	else
	{
		if (i > F_MAXPRECISION) i = F_MAXPRECISION;
		do rec->digits[i --] = 0;
		while (i >= 0 && rec->digits[i] == '0');
		if (i < 0) rec->negative = 0;
	}
}

#ifdef	USE_EXTENDED

// 解析扩展精度浮点数为十进制字符串，并存入浮点数记录中
// 参数：浮点数指针，精度，小数位，浮点数记录
VOID FloatResolve(PEXTENDED pvalue, INT precision, INT decimals, FloatRec *rec)
{
	INT power;
	EXTENDED val;

	// 79位：扩展精度浮点数符号位
	rec->negative = ((_Extended*)pvalue)->exponent >> 15;
	// 64-78位：扩展精度浮点数阶码(阶码 - 0x3fff = 二进制指数)
	rec->exponent = ((_Extended*)pvalue)->exponent & 0x7fff;
	if (!rec->exponent)			// *pvalue = 0
	{
		rec->negative = rec->digits[0] = 0;
		return;
	}
	if (rec->exponent == 0x7fff)// *pvalue = nan or inf
	{
		if (!((*(LPBYTE)pvalue + 7) & 0x80) || !(*(PUINT64)pvalue & 0x7fffffffffffffff))
		{
			lstrcpyA(rec->digits, "INF");
		}
		else
		{
			rec->exponent ++;
			rec->negative = 0;
			lstrcpyA(rec->digits, "NAN");
		}
		return;
	}
	// 阶码转换为十进制指数
	rec->exponent = DECIMAL_EXP(rec->exponent);
	// 0-63位：扩展精度浮点数尾数转换成F_MAXPRECISION位十进制浮点整数格式
	val = *pvalue;
	*((LPBYTE)&val + 9) &= 0x7f;// val = fabs(*pvalue)
	power = F_MAXPRECISION - rec->exponent;
	if (power > 0)				// if (power > 0) val *= (10**power)
	{
		val *= *(PEXTENDED)&_tab0[power & 31];
		power >>= 5;			// power /= 32;
		if (power)
		{
			if (power & 15)
				val *= *(PEXTENDED)&_tab1[(power & 15) - 1];
			power >>= 4;		// power /= 16;
			if (power)
				val *= *(PEXTENDED)&_tab2[power - 1];
		}
	}
	else if (power < 0)			// if (power < 0) val /= (10**power)
	{
		power = -power;
		val /= *(PEXTENDED)&_tab0[power & 31];
		power >>= 5;			// power /= 32;
		if (power)
		{
			if (power & 15)
				val /= *(PEXTENDED)&_tab1[(power & 15) - 1];
			power >>= 4;		// power /= 16;
			if (power)
				val /= *(PEXTENDED)&_tab2[power - 1];
		}
	}
	val += 0.5;					// 四舍五入
	if (val >= _conPrec)
	{
		val /= 10;
		rec->exponent ++;
	}
	// 调整并转换扩展精度浮点数尾数的整数部分rec->digits
	AdjFloatDigits(*(PUINT64)&val >> ((((_Extended*)&val)->exponent - 0x3fff) ^ 0x3f),
		precision, decimals, rec);
}

#else	// USE_EXTENDED

// 解析双精度浮点数为十进制字符串，并存入浮点数记录中
// 参数：浮点数指针，精度，小数位，浮点数记录
VOID FloatResolve(PEXTENDED pvalue, INT precision, INT decimals, FloatRec *rec)
{
	INT power;
	EXTENDED val;

	// 63位：双精度浮点数符号位
	rec->negative = *((LPBYTE)pvalue + 7) >> 7;
	// 52-62位：双精度浮点数阶码(阶码 - 0x3ff = 二进制指数)
	rec->exponent = (*(PUINT64)pvalue >> 52) & 0x7ff;
	if (!rec->exponent)			// *pvalue = 0
	{
		rec->negative = rec->digits[0] = 0;
		return;
	}
	if (rec->exponent == 0x7ff)// *pvalue = nan or inf
	{
		if ((*(PUINT64)pvalue & 0xfffffffffffff) == 0)
		{
			lstrcpyA(rec->digits, "INF");
		}
		else
		{
			rec->exponent ++;
			rec->negative = 0;
			lstrcpyA(rec->digits, "NAN");
		}
		return;
	}
	// 阶码转换为十进制指数
	rec->exponent = DECIMAL_EXP(rec->exponent);
	// 0-51位：双精度浮点数尾数转换成F_MAXPRECISION位十进制浮点整数格式
	val = *pvalue;
	*((LPBYTE)&val + 7) &= 0x7f;// val = fabs(*pvalue)
	power = F_MAXPRECISION - rec->exponent;
	if (power > 0)				// if (power > 0) val *= (10**power)
	{
		val *= *(PEXTENDED)&_tab0[power & 31];
		power >>= 5;			// power /= 32;
		if (power)
			val *= *(PEXTENDED)&_tab1[power - 1];
	}
	else if (power < 0)			// if (power < 0) val /= (10**power)
	{
		power = -power;
		val /= *(PEXTENDED)&_tab0[power & 31];
		power >>= 5;			// power /= 32;
		if (power)
			val /= *(PEXTENDED)&_tab1[power - 1];
	}

	// 16位十进制浮点整数四舍五入
	val += 0.5;
	if (val >= _conPrec)
	{
		val /= 10;
		rec->exponent ++;
	}
	// 调整并转换扩展精度浮点数尾数的整数部分rec->digits
	// 清除52-63位，加隐藏的高位，F_MAXPRECISION=17，高位超过52位，所以左移
	AdjFloatDigits(((*(PUINT64)&val & 0x000fffffffffffff) | 0x0010000000000000) <<
		-(52 - ((*(PUINT64)&val >> 52) - 0x3ff)), precision, decimals, rec);
}

#endif	// !USE_EXTENDED

// 输出指数字符串到buffer，返回指数字符串长度
INT PutExponent(LPSTR buffer, CONST FloatRec *rec)
{
	LPSTR p = buffer;
	INT e, exp = rec->digits[0]? rec->exponent - 1 : 0;
	*p ++ = rec->negative & 0x80? 'E' : 'e';
	if (exp < 0)
	{
		exp = -exp;
		*p ++ = '-';
	}
	else *p ++ = '+';
	if ((e = (exp / 1000)) != 0)
	{
		*p ++ = e + 0x30;
		exp %= 1000;
	}
	*p ++ = exp / 100 + 0x30;
	exp %= 100;
	*(PUSHORT)p = (((exp % 10) << 8) | (exp / 10)) + 0x3030;
	return (INT)(p - buffer + 2);
}

// 浮点数转换为字符串。参数：字符串，浮点数
LPSTR FloatToStr(LPSTR str, EXTENDED value)
{
	INT exp;
	FloatRec rec;
	LPSTR pd = rec.digits;
	LPSTR ps = str;

	// 解析浮点数，并将信息保存在rec
	FloatResolve(&value, 15, 9999, &rec);
	// 打印负数符号
	if (rec.negative) *ps ++ = '-';
	// NAN or INF
	if (*pd > '9')				
	{
		memcpy(ps, pd, 4);
		return str;
	}
	exp = rec.exponent;
	// 如果十进制指数大于15或者小于-3，转换为指数形式
	if (exp > 15 || exp < -3)	
	{
		*ps ++ = *pd ++;
		if (*pd)
			for (*ps ++ = '.'; *pd; *ps ++ = *pd ++);
		ps += PutExponent(ps, &rec);
		*ps = 0;
		return str;
	}
	// 否则，转换为小数形式
	if (exp <= 0)
	{
		*ps ++ = '0';
		if (*pd)
		{
			for (*ps ++ = '.'; exp < 0; *ps ++ = '0', exp ++);
			while (*ps ++ = *pd ++);
		}
		else *ps = 0;
	}
	else
	{
		for (; exp > 0 && *pd; *ps ++ = *pd ++, exp --);
		if (*pd)
		{
			*ps ++ = '.';
			while (*ps ++ = *pd ++);
		}
		else
		{
			memset(ps, '0', exp);
			ps[exp] = 0;
		}
	}
	return str;
}

2个版本的代码加起来很长，但还有个自写的springf函数（下篇文章开始介绍）也要用到本文除FloatToSt函数外的全部代码。

代码开头的USE_EXTENDED为编译条件，如果你的编译系统不支持80位扩展精度浮点数，可将该定义注释掉。

前面说了，由于该代码主要是学习用的，因此数据转换层次较低，涉及到的有关浮点数格式的知识，可在网上搜索到。当然，知道是一回事，而具体怎样去操作则又是另一回事了，一些关键地方，我都作了较详细的注释，相信能对初学者正确理解浮点数格式有所帮助。例如，如何在不调用C有关函数，不使用汇编而快速的求一个浮点数的绝对值？本文代码就直接对浮点数进行操作：*((LPBYTE)&val + 7) &= 0x7f;（双精度浮点数）和*((LPBYTE)&val + 9) &= 0x7f;（扩展精度浮点数），也就是直接将浮点数的最高位置零，这当然比什么if (val < 0) val = -val语句快多了。不过，如果你要说后者的可移植性好，那我就无话可说了。要说可移植性，前者也可办到的，修改一下：*((LPBYTE)&val + sizeof(val) - 1) &= 0x7f;不就行了么，除非浮点数格式规则改变。只不过本文代码主要用来学习，用显式的方式更有意义。

80位扩展精度浮点数的有效数字为19位，而64位双精度浮点数有效数字为15 - 16位，本文的解析函数FloatResolve分别用了19位和17位的最大转换精度，尽可能的多显示几位，这主要是为自写的sprintf函数（另文介绍）做准备的，本文的浮点数转换字符串函数FloatToStr只用了最大15位的精度。

下面是个很简单的调用例子：

int main(int argc, char* argv[])
{
	CHAR s[32];
	UINT64 inf = 0x7ff0000000000000;
	double v = -1.230E45;
	INT a, b;

	puts(FloatToStr(s, -10000));
	puts(FloatToStr(s, 123456789012345678));
	puts(FloatToStr(s, 1234567890.12345678));
	puts(FloatToStr(s, 0.0001234567890));
	puts(FloatToStr(s, -0.00001234567890));
	puts(FloatToStr(s, v));
	puts(FloatToStr(s, 0));
	puts(FloatToStr(s, *(double*)&inf));

	system("pause");
	return 0;
}

  下面是运行结果：<p></p>
<pre class="cpp" name="code">-10000
1.23456789012346e+017
1234567890.12346
0.000123456789
-1.23456789e-005
-1.23e+045
0
INF
请按任意键继续. . .</pre>

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

水平有限，错误在所难免，欢迎指正和指导。邮箱地址：[e-mail]