如何在C语言中将逗号分隔字符*转换为uint32_t[]数组

我想将逗号分隔的字符*转换为C语言中的uint32_数组[]。有没有简单的方法/例程

<>我已经花了很多时间在C++上找到了很多解决方案，但不是C那样的： 但我认为将char*转换为字符串，再转换为字符串流，再转换为向量并使用向量，并不是一个好的解决方案

char input[] = "1 , 2 , 34, 12, 46, 100";

到

我将感谢任何帮助。非常感谢。

多种方法中的一种：

您可以使用

strtok（）

代替

sscanf（）

和

strchr（）

，但这会修改

输入，这可能是不需要的

如果输入是流而不是字符串，则更简单：

int converted = 0 ;
int i = 0 ;
do
{
    converted = fscanf( fd, "%d,", &output[i] ) ;
    i++ ;

} while( !feof( fd ) && converted != 0 ) ;

我没有包含任何防止<代码>输出[i] <代码>超出界限的方法-你也需要考虑这一点。 一种方法（多种方法中的一种）：
您可以使用
strtok（）
代替
sscanf（）
和
strchr（）
，但这会修改
输入，这可能是不需要的

如果输入是流而不是字符串，则更简单：

int converted = 0 ;
int i = 0 ;
do
{
    converted = fscanf( fd, "%d,", &output[i] ) ;
    i++ ;

} while( !feof( fd ) && converted != 0 ) ;

我没有包含任何防止<代码>输出[i] <代码>超出界限的方法-你也需要考虑这一点。 通读字符串一次，了解如何调整数组大小：
uint32_t n = 1;
for (uint32_t idx = 0; idx < strlen(input); idx++) {
    if (input[idx] == ',') {
        n++;
    }
}

填充数组。在不破坏字符串的情况下执行此操作的一种方法是，在逗号分隔的字符串中保留一对指向包含所需数字元素的子字符串的开始和结束的指针，并循环遍历字符串中的所有字符：

#define MAX_LEN 13
char* start = &input[0];
char* end = &input[0];
char entry[MAX_LEN];
uint32_t entry_idx = 0;
int finished = 0; // false
do {
    end = strchr(start, ',');
    if (!end) {
        end = input + strlen(input);
        finished = 1;
    }
    memcpy(entry, start, end - start);
    entry[end - start] = '\0';
    sscanf(entry, "%u", &output[entry_idx++]);
    start = end + 1;
} while (!finished);

MAX\u LEN
是13，因为
uint32\u t
不太可能超过13位。对于2100年制造的计算机，您可以将其延长到未来的证明时间

使用完阵列后，请确保释放该阵列：

free(output); 
output = NULL;

通读字符串一次，了解如何调整数组大小：

uint32_t n = 1;
for (uint32_t idx = 0; idx < strlen(input); idx++) {
    if (input[idx] == ',') {
        n++;
    }
}

填充数组。在不破坏字符串的情况下执行此操作的一种方法是，在逗号分隔的字符串中保留一对指向包含所需数字元素的子字符串的开始和结束的指针，并循环遍历字符串中的所有字符：

#define MAX_LEN 13
char* start = &input[0];
char* end = &input[0];
char entry[MAX_LEN];
uint32_t entry_idx = 0;
int finished = 0; // false
do {
    end = strchr(start, ',');
    if (!end) {
        end = input + strlen(input);
        finished = 1;
    }
    memcpy(entry, start, end - start);
    entry[end - start] = '\0';
    sscanf(entry, "%u", &output[entry_idx++]);
    start = end + 1;
} while (!finished);

MAX\u LEN
是13，因为
uint32\u t
不太可能超过13位。对于2100年制造的计算机，您可以将其延长到未来的证明时间

使用完阵列后，请确保释放该阵列：

free(output); 
output = NULL;

以下是一种方法：

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

typedef struct
{
    int* values;
    int  count;
}
output_t;

output_t Read(char input[])
{
    int*  values = NULL;
    int   count  = 0;
    char* pch    = strtok(input,", ");

    while (pch != NULL)
    {
        values = realloc(values,(count+1)*sizeof(*values));
        values[count++] = atoi(pch);
        pch = strtok(NULL,", ");
    }

    return (output_t){values,count};
}

#包括
#包括
#包括
类型定义结构
{
int*值；
整数计数；
}
输出t；
输出读取（字符输入[]）
{
int*值=NULL；
整数计数=0；
char*pch=strtok（输入“，”）；
while（pch！=NULL）
{
值=realloc（值，（计数+1）*sizeof（*值））；
值[计数++]=atoi（pch）；
pch=strtok（空，“，”）；
}
返回（输出）{值，计数}；
}

下面是一个用法示例：

void Example()
{
    char input[] = "1 , 2 , 34, 12, 46, 100";
    output_t output = Read(input);
    for (int i=0; i<output.count; i++)
        printf("%d\n",output.values[i]);
    free(output.values);
}

void示例（）
{
字符输入[]=“1,2,34,12,46,100”；
输出=读取（输入）；
对于（int i=0；i，这里有一种方法：

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

typedef struct
{
    int* values;
    int  count;
}
output_t;

output_t Read(char input[])
{
    int*  values = NULL;
    int   count  = 0;
    char* pch    = strtok(input,", ");

    while (pch != NULL)
    {
        values = realloc(values,(count+1)*sizeof(*values));
        values[count++] = atoi(pch);
        pch = strtok(NULL,", ");
    }

    return (output_t){values,count};
}

#包括
#包括
#包括
类型定义结构
{
int*值；
整数计数；
}
输出t；
输出读取（字符输入[]）
{
int*值=NULL；
整数计数=0；
char*pch=strtok（输入“，”）；
while（pch！=NULL）
{
值=realloc（值，（计数+1）*sizeof（*值））；
值[计数++]=atoi（pch）；
pch=strtok（空，“，”）；
}
返回（输出）{值，计数}；
}

下面是一个用法示例：

void Example()
{
    char input[] = "1 , 2 , 34, 12, 46, 100";
    output_t output = Read(input);
    for (int i=0; i<output.count; i++)
        printf("%d\n",output.values[i]);
    free(output.values);
}

void示例（）
{
字符输入[]=“1,2,34,12,46,100”；
输出=读取（输入）；
对于（int i=0；i，这里有一个递归算法，只进行一次传递。它在最深层分配，并在输出时填充：

int *cvt(char *input, int *level)
{
    char *cp = strtok(input, ", ");
    if (cp == NULL) {
        /* No more separators */
        return (int *) malloc(sizeof(int) * *level);
    }

    int my_index = -1;
    int n;
    if (sscanf(cp, "%d", &n) == 1) {
        my_index = *level;
        *level += 1;
    } else {
        printf("Invalid integer token '%s'\n", cp);
    }
    int *array = cvt(NULL, level);
    if (my_index >= 0) {
        array[my_index] = n;
    }
    return array;
}

致电：

int main(int ac, char **av)
{
    char input[] = "1, 2, bogus, 4, 8, 22, 33, 55";
    int n_array = 0;
    int *array = cvt(input, &n_array);

    int i;
    printf("Got %d members:\n", n_array);
    for (i = 0; i < n_array; ++i)
        printf("%d ", array[i]);
    printf("\n");

    return 0;
}

int main（int ac，char**av）
{
字符输入[]=“1，2，伪，4，8，22，33，55”；
int n_数组=0；
int*数组=cvt（输入和n_数组）；
int i；
printf（“获得%d个成员：\n”，n\u数组）；
对于（i=0；i
这里有一个递归算法，只进行一次传递。它在最深层次分配，并在退出时填充：

int *cvt(char *input, int *level)
{
    char *cp = strtok(input, ", ");
    if (cp == NULL) {
        /* No more separators */
        return (int *) malloc(sizeof(int) * *level);
    }

    int my_index = -1;
    int n;
    if (sscanf(cp, "%d", &n) == 1) {
        my_index = *level;
        *level += 1;
    } else {
        printf("Invalid integer token '%s'\n", cp);
    }
    int *array = cvt(NULL, level);
    if (my_index >= 0) {
        array[my_index] = n;
    }
    return array;
}

致电：

int main(int ac, char **av)
{
    char input[] = "1, 2, bogus, 4, 8, 22, 33, 55";
    int n_array = 0;
    int *array = cvt(input, &n_array);

    int i;
    printf("Got %d members:\n", n_array);
    for (i = 0; i < n_array; ++i)
        printf("%d ", array[i]);
    printf("\n");

    return 0;
}

int main（int ac，char**av）
{
字符输入[]=“1，2，伪，4，8，22，33，55”；
int n_数组=0；
int*数组=cvt（输入和n_数组）；
int i；
printf（“获得%d个成员：\n”，n\u数组）；
对于（i=0；i
我将把我的帽子扔进环中，对数据进行一次传递。我估计所需的数组大小是最坏的情况，其中每个数据的形式为“n”，因此每个数字两个字节，然后调整大小

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

typedef unsigned int uint32_t;

int main (void) {
    char input[] = "1 , 2 , 34, 12, 46, 100";
    uint32_t *output, *temp;
    char *tok;
    int elements = 0;
    int len = 1 + strlen(input) / 2;            // estimate max num of elements
    output = malloc(len * sizeof(*output));
    if (output == NULL)
        exit(-1);                               // memory alloc error

    tok = strtok(input, ", ");                  // parse the string
    while (tok != NULL) {
        if (elements >= len)
            exit(-2);                           // error in length assumption
        if (1 != sscanf(tok, "%u", output + elements))
            exit(-3);                           // error in string format
        elements++;
        tok = strtok(NULL, ", ");
    }

    temp = realloc(output, elements * sizeof(*output)); // resize the array
    if (temp == NULL)
        exit(-4);                               // error in reallocating memory
    output = temp;

    for (len=0; len<elements; len++)
        printf("%u ", output[len]);
    printf("\n");
    free(output);
    return 0;
}

我将把我的帽子扔进环中，对数据进行一次传递。我估计所需的数组大小是最坏的情况，其中每个数据的形式为“n”，因此每个数字两个字节，然后调整它的大小

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

typedef unsigned int uint32_t;

int main (void) {
    char input[] = "1 , 2 , 34, 12, 46, 100";
    uint32_t *output, *temp;
    char *tok;
    int elements = 0;
    int len = 1 + strlen(input) / 2;            // estimate max num of elements
    output = malloc(len * sizeof(*output));
    if (output == NULL)
        exit(-1);                               // memory alloc error

    tok = strtok(input, ", ");                  // parse the string
    while (tok != NULL) {
        if (elements >= len)
            exit(-2);                           // error in length assumption
        if (1 != sscanf(tok, "%u", output + elements))
            exit(-3);                           // error in string format
        elements++;
        tok = strtok(NULL, ", ");
    }

    temp = realloc(output, elements * sizeof(*output)); // resize the array
    if (temp == NULL)
        exit(-4);                               // error in reallocating memory
    output = temp;

    for (len=0; len<elements; len++)
        printf("%u ", output[len]);
    printf("\n");
    free(output);
    return 0;
}

#包括
#包括
#包括
#包括
int getsize（char*str，char*delimiters）//给出最终uint32\u t数组的大小[]
{
整数计数=0；
char*st=strdup（str），*t=strtok（st，分隔符）；
while（t）
{
计数++；
t=strtok（空，分隔符）；
}
免费（st）；
返回计数；
}
uint32\u t*Char\u to_数组（Char*data，Char*分隔符，int*siz）//siz是获取数组大小的指针
{
char*st=strdup（数据），*t=NULL；//dup字符串，传递字符串上的strtok mage更改
*siz=getsize（数据、分隔符）；
uint32_t*buf=（uint32_t*）malloc（（*siz）*4）；
t=strtok（st，分隔符）；//按“”拆分字符串
int i=0；
while（t）
{
buf[i]=atoi（t）；
t=strtok（空，分隔符）；
i++；
}
免费（st）；
返回buf；
}

这里是一个带有主函数的测试

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

int main()
{
  int getsize(char* str, char* delimiters), siz = 0, i = 0;
  uint32_t* Char_to_Array(char *data, char* delimiters, int *x);
  uint32_t* t = Char_to_Array("123, 156, 4658,7878", " ,", &siz);
  while(i<siz)
  {
    printf("array[%d] = %d\n", i, t[i]);
    i++;
  }
  free(t);
  return 0;
}

#包括
#包括
#包括
#包括
int main（）
{
int getsize（char*str，char*分隔符），siz=0，i=0；