将整数数组转换为C中的字符数组

Question

我需要知道如何将整数数组转换为C中的字符数组。 我有1000个元素int阵列，我将有4000个字节大小的字符阵列。 如何将每个整数元素填充到字符数组中，以便在打印时，将所有整数显示在单个字符串中。 示例：dsid_list [3] = {1000，1001，1002}; 那么char_dsid_array应该具有“ 100010011002” 以下是代码段，试图执行相同的代码。

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

int main()
{
        uint32_t dsid_count = 1000;

        printf("dsid_count:%lu\n",dsid_count);

        uint32_t dsid_list[dsid_count];
        uint32_t i;

        printf("start\n");
        for(i=0; i<dsid_count; i++) {
                dsid_list[i] = i;
        }
        printf("Size of dsid_list:%lu\n", sizeof(dsid_list));

        //char char_dsid_array[sizeof(dsid_list)];
        char *char_dsid_array = (char*)malloc(sizeof(dsid_list) + 1);
        
        i=0;
        char* temp = (char*)malloc(4);
        char* temp1 = char_dsid_array;
        for(i=0; i<dsid_count; i++) {
                sprintf(temp, "%lu", dsid_list[i]);
                if(i == 0) {
                        strcpy(char_dsid_array, temp);
                }
                else {
                        strcat(char_dsid_array, temp);
                }
                char_dsid_array = char_dsid_array + 4;
        }
        char_dsid_array = temp1;
        printf("DSID list: %s\n", char_dsid_array);

        free(char_dsid_array);
        free(temp1);
        free(temp);

        return 0;
}

Answer 1

• 无论如何，uint32_t可以将值提取到4294967295（2 ³² - 1），因此4 bytes字符空间不足以将该数字存储为字符串。

• 幸运的是，您正在尝试使用范围中的数字来创建字符串[0..999]

• 只需循环浏览数字，然后从sprintf（）使用返回值字符串的后缀号。 sprintf（）（＆amp; printf（）兄弟姐妹）返回成功写入目标的字符数。

// after malloc
    int slen = 0;
    for (int num = 0; num < dsid_count; ++num)
        slen += sprintf (char_dsid_array + slen, "%d", num);

    printf("DSID list: %s\n", char_dsid_array);

• 但是，如果dsid确实大于数字1000，则需要分配足够的空间，例如10010（10 x 1001代码> = 10010）字节，以使千ID在更安全的侧面。
• 生成字符串完成后，请使用realloc（）在必要时修剪未使用的内存，例如：

char* ptr = realloc (char_dsid_array, slen +1);
if (ptr) char_dsid_array = ptr;
else /* error handling */

Answer 2

4个字符足以存储0到999之间整数的基本10字符串表示形式，但通常不足以存储任意int。您可以使用snprintf来计算生成字符串表示形式所需的空间数量。我建议在初始化数组，然后分配一次空间时累积所需的大小。例如：

#include <assert.h>
#include <stdio.h>
#include <inttypes.h>
#include <string.h>
#include <stdlib.h>
void * xmalloc(size_t s);

int
main(int argc, char **argv)
{
    size_t dsid_count = argc > 1 ? strtol(argv[1], NULL, 10) : 1000;
    size_t needed = 0;
    printf("dsid_count:%zu\n", dsid_count);

    uint32_t *dsid_list = xmalloc(dsid_count * sizeof *dsid_list);
    uint32_t i;

    for( size_t i = 0; i < dsid_count; i+= 1 ){
        dsid_list[i] = i;
        needed += snprintf(NULL, 0, "%" PRIu32, dsid_list[i]);
    }

    char *int_string = xmalloc(needed + 1);
    char *end = int_string;
    size_t avail = needed + 1;

    for( size_t i = 0; i < dsid_count; i+= 1 ){
        int s = snprintf(end, avail, "%" PRIu32, dsid_list[i]);
        end += s;
        avail -= s;
    }
    assert( end - int_string == needed );
    printf("%s\n", int_string);
}


void *
xmalloc(size_t s)
{
    void *rv = malloc(s);
    if( rv == NULL ){
        perror("malloc");
        exit(EXIT_FAILURE);
    }
    return rv;
}

Answer 3

size_t print(char *buff, size_t size, int *array)
{
    size_t pos = 0;
    int len = 0;

    while(size--)
    {
        len = snprintf(buff + (!!buff) * pos, !!buff * INT_MAX, "%d", *array++);
        if(len < 0) { /* error andling */}
        pos += len;
    }
    return pos;
}

char *printIntArray(size_t size, int *array)
{
    char *string = malloc(print(NULL, size, array) + 1);

    if(string) print(string, size, array);
    return string;
}

int main(void)
{
    int array[3] = {1000, 1001, 1002};
    char *b;
    printf("\"%s\"\n", b = printIntArray(3, array));
    free(b);
}

Answer 4

先生，下面有案例的代码示例：

dsid_list [3] = {1000，1001，1002};那么char_dsid_array应该有
“ 100010011002”

请注意一些安全的问题，在为阵列添加新整数之前，我们必须检查是否有足够的空间，如果有足够的空间，我将在consantate之前：

if（sizeof（my_list）＆gt;（str_number（str_number）（str_number） ） + strlen（my_list）））

另一个可爱的安全求职者是snprintf，此功能改进sprintf以避免溢出。

Here's an online working code

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

#define INT_CHARS 11 // 5 should be enough, 1000-1999 span 4 digits + '\0', 11 bits are enough for biggest integer number

int main()
{
    int n;
    int length;
    char str_number[INT_CHARS]; // size should enoght to store all digits, null terminator,
    int dsid_list[3] = {1000, 1001, 1002};
    char my_list[4001]= "";

    length = sizeof(dsid_list) / sizeof(int);

    for(n = 0; n < length; n++)
    {
        snprintf(str_number, INT_CHARS, "%d", dsid_list[n]);
        if(sizeof(my_list) > (strlen(str_number) + strlen(my_list)))
        {
            strcat(my_list, str_number);
        }
        else
        {
            printf("Not enough space to store more data\n");
            break;
        }
    }
    printf("my list = %s", my_list);
}