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
整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  整数  小数点  小数  小数  小数  
整数  整数  整数  整数  整数  整数  整数  整数   8     4    5      .     1    2     3    

函数名称：整数转字符串，加入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] = '';

    index_frac = MAX_LEN - 2;

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

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

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

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

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

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

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

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

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

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

    return ret;
}

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

函数名称：整数转字符串，无小数点，用于功率参数的转换
函数功能：将整数保存是字符数组中，字符数组大小是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] = '';

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

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

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

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

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

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

    return ret;
}


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

    uint32_t value = 12345;

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

    int_pow_to_string(str, value);

    printf("%s
", str);

    int_to_string(str, value, 3);

    printf("%s
", str);

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

代码如上所示，

运行结果

000000000000000

raw_d = 12345

12345

12.345

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