寻求snprintf()替代方案：嵌入式平台下float转字符数组实现

针对你在嵌入式平台上遇到的float转字符串问题（不能用snprintf()，因为内部依赖double导致性能拖慢），结合平台支持32位NEON FPU的特性，我整理了一个轻量高效的实现方案，完全满足正负float转换、非指数表示、小数点后最多保留三位的需求：

咱们不用依赖标准库的格式化函数，直接用float原生运算来拆分数据，步骤很清晰：

1. 先处理符号：判断float是否为负数，标记后取绝对值
2. 拆分整数部分：通过浮点取整得到整数部分，再转成字符串
3. 拆分小数部分：取原数和整数部分的差值，放大1000倍后四舍五入，再拆分为三位数字（最多保留三位，末尾的0可以按需省略）
4. 把符号、整数部分、小数点（如果有小数）、小数部分拼接成最终字符串

因为平台支持NEON FPU，所有浮点运算都会被编译器优化成高效的NEON指令，完全不用额外写汇编，性能拉满。

#include <math.h> // 用到floorf，嵌入式平台如果连这个都没有，可以自己实现简单的取整

// 注意：buf需要足够大，最坏情况（比如-999999.999）需要至少12字节空间（含结束符）
void float_to_str(float f, char* buf, int buf_size) {
    if (buf_size < 2) return; // 至少留空间给结束符
    int idx = 0;

    // 1. 处理符号
    int is_negative = 0;
    if (f < 0.0f) {
        is_negative = 1;
        f = -f;
        if (buf_size > 1) {
            buf[idx++] = '-';
        } else {
            buf[0] = '\0';
            return;
        }
    }

    // 2. 处理整数部分
    float int_part_f = floorf(f);
    int int_part = (int)int_part_f;

    // 先把整数转成反向字符串，再反转回来（避免额外缓冲区）
    char temp[10]; // 足够存32位float的最大整数部分（2^24左右，最多8位）
    int temp_idx = 0;
    if (int_part == 0) {
        temp[temp_idx++] = '0';
    } else {
        while (int_part > 0 && temp_idx < sizeof(temp)) {
            temp[temp_idx++] = (int_part % 10) + '0';
            int_part /= 10;
        }
    }
    // 反转到目标缓冲区
    while (temp_idx > 0 && idx < buf_size - 1) {
        buf[idx++] = temp[--temp_idx];
    }

    // 3. 处理小数部分（最多三位）
    float frac_part = f - int_part_f;
    // 放大1000倍并四舍五入
    int frac_scaled = (int)(frac_part * 1000.0f + 0.5f);

    if (frac_scaled > 0 && idx < buf_size - 1) {
        buf[idx++] = '.';
        // 拆分三位小数，去掉末尾的0
        int digits[3] = {
            (frac_scaled / 100) % 10,
            (frac_scaled / 10) % 10,
            frac_scaled % 10
        };
        int valid_digits = 3;
        // 从后往前找第一个非0的位置，确定有效位数
        while (valid_digits > 0 && digits[valid_digits - 1] == 0) {
            valid_digits--;
        }
        // 如果有效位数为0，就不输出小数（不过这里frac_scaled>0，所以至少有一位）
        for (int i = 0; i < valid_digits && idx < buf_size - 1; i++) {
            buf[idx++] = digits[i] + '0';
        }
    }

    // 添加结束符
    buf[idx] = '\0';
}

• 符号处理：先判断正负，标记后取绝对值，避免后续运算处理负数的麻烦
• 整数部分转换：用floorf()（float版本的取整，比floor快，因为不用转double）得到整数部分，然后用简单的取模/除法转成字符串，避免依赖itoa这类非标准函数
• 小数部分处理：通过放大1000倍+四舍五入，把小数转成整数，再拆分每一位；同时去掉末尾的0，实现“最多保留三位”的需求（比如1.2会输出"1.2"，1.23会输出"1.23"，1.2345会输出"1.235"）
• 缓冲区安全：全程检查缓冲区剩余空间，避免越界

如果你的平台连floorf()都没有，完全可以自己实现一个简单的float取整：

float my_floorf(float f) {
    int i = (int)f;
    return (f < 0.0f && (float)i != f) ? (float)(i - 1) : (float)i;
}

这个实现完全避开了double类型，所有运算都是32位float，编译器会自动利用NEON FPU加速，性能比snprintf()快很多，而且代码体积极小，非常适合嵌入式场景。

内容的提问来源于stack exchange，提问作者Elmi