c语言实现整数转换为字符串——不考虑负数

#include <stdio.h>
#include <string.h>

#define MAX_LEN 16
#define ESP  1e-5

typedef int int32_t;
typedef unsigned int uint32_t;

/***********************************************************************
  0    1     2    3     4    5     6     7    8     9    10    11     12    13   14   15
整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  小数点  小数  小数  小数  \0
整数  整数  整数  整数  整数  整数  整数  整数   8     4    5      .     1    2     3    \0

函数名称：整数转字符串，加入4位小数，和小数点
函数功能：将整数保存是字符数组中，字符数组大小是16位char，最后一位是0x00
入口参数：str，字符指针，value，需要转换的数据，precision小数点保留的位数
出口参数：ret 返回值，-1，error 否则，返回转换的数量，包括小数点'.'
备 注：

基本思路：
由于电压、电流都是mv，ma为单位，上位机已经扩大1000倍，作为整数下发stm32中
后4位最为小数，中间添加小数点'.'

求余数，保存，直到数据为0

目前，不考虑负数，因为电压、电流均为正数，需要在上层函数，进行数据的判断。
***********************************************************************/
int32_t int_to_string(char *str, const uint32_t value, const uint32_t precision)
{
    int32_t ret = 0;       //返回值
    uint32_t prv_precision = precision;  //小数点保留数量3位
    uint32_t integer_val = value;    //整数部分
    uint32_t int_num = 0;            //整数的位数
    uint32_t mod = 0;                //每一位的数据，用于保存到数组中
    uint32_t index_int = 0;    //整数最低位的保存位置 16-precision-1-1-1, 第9位开始保存整数
    uint32_t index_frac = 0;                         //用于指示小数的下标

    if (integer_val >= 840000)
    {
        integer_val = 840000;
    }

    str[MAX_LEN - 1] = '\0';

    index_frac = MAX_LEN - 2;

    //保存小数部分，先保存最低位小数
    do
    {
        prv_precision--;

        mod = integer_val % 10; //取余
        integer_val /= 10;

        //printf("\nmod=%d\n", mod);
        str[index_frac] = mod + 0x30;               //保存数据到字符数组中
        //printf("str[%d]=%c\n", index_frac, str[index_frac]);
        index_frac--;
        //printf("index_frac=%d\n", index_frac);
        //printf("prv_precision=%d\n",prv_precision);
    }
    while (prv_precision);

    str[MAX_LEN - precision - 2] = '.'; //保存小数点  第10位保存小数点

    //整数的位数的保存，先保存最低位整数
    index_int = MAX_LEN - precision - 3;
    do
    {
        int_num++;  //至少是1位
        //printf("\nint_num=%d\n", int_num);

        mod = integer_val % 10; //先求余数
        //printf("mod=%d\n", mod);
        integer_val /= 10;      //再除10
        //printf("integer_val=%d\n", integer_val);
        str[index_int] = mod + 0x30;    //保存至数组中
        //printf("str[%d]=%c\n", index_int, str[index_int]);
        index_int--;                    //保存指针减
        //printf("index_int=%d\n", index_int);
    }
    while (integer_val);

    ret = int_num + precision + 1;  //转换总量=整数转换的数量（1-3位）+小数转换的数量(始终是precision位)+'.'
    //printf("\nret=%d\n", ret);

    uint32_t loop = ret + 1; //加最后一位0x00 '\0'，=总共需要搬运的位数
    //printf("loop=%d\n", loop);

    index_frac = 0;     //新的保存从0下标开始
    index_int++;        //从这里开始搬运，之前do-while循环已经减去一，这里要加回去
    //printf("index_int=%d\n", index_int);

    //数据整体搬迁到str[0],以省去前置的零
    do
    {
        loop--;
        str[index_frac] = str[index_int];
        index_int++;    //源数据的开始搬运的下标
        index_frac++;   //新数据的开始保存的下标
        //printf("loop = %d\n",loop);
    }
    while (loop);

    return ret;
}

/***********************************************************************
  0    1     2    3     4    5     6     7    8     9    10    11   12    13   14   15
整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  \0
整数  整数  整数  整数  整数  整数  整数  整数  整数  整数    1    2     3     4    5   \0

函数名称：整数转字符串，无小数点，用于功率参数的转换
函数功能：将整数保存是字符数组中，字符数组大小是16位char，最后一位是0x00
入口参数：str，字符指针，value，需要转换的数据
出口参数：ret 返回值，-1，error 否则，返回转换的数量
备 注：

基本思路：
直接将整数转换保存至字符串中，求余数，并保存，直到数据为零

目前，不考虑负数，因为功率均为正数，需要在上层函数，进行数据的判断。
***********************************************************************/
int32_t int_pow_to_string(char *str, const uint32_t value)
{
    int32_t ret = 0;       //返回值
    uint32_t integer_val = value;    //整数
    uint32_t int_num = 0;            //整数的位数
    uint32_t mod = 0;                //每一位的数据，用于保存到数组中
    uint32_t index_int = 0;          //整数最低位的保存位置 16-precision-1-1-1, 第9位开始保存整数
    uint32_t index_front = 0;        //用于指示新数据的下标，数组的开始处str[0]

    str[MAX_LEN - 1] = '\0';

    //整数的位数的保存，先保存最低位整数
    index_int = MAX_LEN - 2;
    do
    {
        int_num++;  //至少是1位
        //printf("\nint_num=%d\n", int_num);

        mod = integer_val % 10; //先求余数
        //printf("mod=%d\n", mod);
        integer_val /= 10;      //再除10
        //printf("integer_val=%d\n", integer_val);
        str[index_int] = mod + 0x30;    //保存至数组中
        //printf("str[%d]=%c\n", index_int, str[index_int]);
        index_int--;                    //保存指针减
        //printf("index_int=%d\n", index_int);
    }
    while (integer_val);

    ret = int_num;  //转换总量=整数转换的数量
    //printf("\nret=%d\n", ret);

    uint32_t loop = ret + 1; //加最后一位0x00 '\0'，=总共需要搬运的位数
    //printf("loop=%d\n", loop);

    index_int++;        //从这里开始数据搬运，之前do-while循环已经减去一，这里要加回去
    //printf("index_int=%d\n", index_int);

    //数据整体搬迁到str[0],以省去前置的零
    do
    {
        loop--;
        str[index_front] = str[index_int];
        index_int++;        //源数据的开始搬运的下标
        index_front++;      //新数据的开始保存的下标
        //printf("loop = %d\n",loop);
    }
    while (loop);

    return ret;
}

int main(void)
{
    char str[MAX_LEN] = {0};
    memset(str, '0', sizeof(str));
    str[MAX_LEN - 1] = '\0';
    printf("%s\n", str);

    uint32_t value = 12345;

    printf("raw_d = %u\n", value);

    int_pow_to_string(str, value);

    printf("%s\n", str);

    int_to_string(str, value, 3);

    printf("%s\n", str);

    //printf("sizeof(str) = %d\n", sizeof(str));
    //printf("str = %d\n", *(str + 1));
    return 0;
}

代码如上所示，

运行结果

000000000000000

raw_d = 12345

12345

12.345

原理很简单了，可以直接看代码