用c语言字符串分割成数组

可以使用C语言中的strtok函数将一个字符串分割成多个子字符串，存储到一个数组中。例如：

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

int main() {
    char str[] = "apple,banana,orange";
    char *token;
    char *array[10];
    int i = 0;

    token = strtok(str, ",");
    while (token != NULL) {
        array[i++] = token;
        token = strtok(NULL, ",");
    }

    for (int j = 0; j < i; j++) {
        printf("%s\n", array[j]);
    }

    return 0;
}

这段代码将字符串"apple,banana,orange"按照逗号分割成三个子字符串，并存储到一个字符串数组中。输出如下：

apple
banana
orange

其中strtok函数的第一个参数为需要分割的字符串，第二个参数为分隔符。每次调用strtok函数返回一个指向下一个子字符串的指针，当没有更多的子字符串时返回NULL。

相关问题

C语言优化代码从stream中根据\n分割成字符串存储,成数组，再将数组中每个字符串按照逗号存储成cstring二维数组

假设输入的 stream 存储在字符数组中，可以使用以下代码实现分割和存储：

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

#define MAX_STR_LEN 100 // 定义最大字符串长度
#define MAX_STR_NUM 100 // 定义最大字符串数量

int main()
{
    char stream[] = "hello\nworld\nthis\nis\na\ntest\n"; // 假设输入的 stream 存储在字符数组中
    char str[MAX_STR_NUM][MAX_STR_LEN]; // 定义字符串数组
    char cstr[MAX_STR_NUM][MAX_STR_LEN][MAX_STR_LEN]; // 定义 C 字符串二维数组
    int i = 0, j = 0, k = 0, n = 0;

    // 根据 '\n' 分割字符串并存储
    for (i = 0; stream[i] != '\0'; i++) {
        if (stream[i] == '\n') {
            str[n][j] = '\0'; // 以 '\0' 结尾
            n++;
            j = 0;
        } else {
            str[n][j] = stream[i];
            j++;
        }
    }

    // 将每个字符串按逗号分割并存储到 C 字符串二维数组中
    for (i = 0; i < n; i++) {
        j = 0;
        k = 0;
        while (str[i][k] != '\0') {
            if (str[i][k] == ',') {
                cstr[i][j][n] = '\0'; // 以 '\0' 结尾
                j++;
                k++;
            } else {
                cstr[i][j][k] = str[i][k];
                k++;
            }
        }
        cstr[i][j][k] = '\0'; // 以 '\0' 结尾
    }

    // 打印 C 字符串二维数组
    for (i = 0; i < n; i++) {
        for (j = 0; cstr[i][j][0] != '\0'; j++) {
            printf("%s ", cstr[i][j]);
        }
        printf("\n");
    }

    return 0;
}

注意事项：

1. 定义两个常量 MAX_STR_LEN 和 MAX_STR_NUM，分别表示最大字符串长度和最大字符串数量。可以根据实际情况进行调整。
2. 分割字符串时，需要注意末尾的 '\0'。
3. 存储 C 字符串时，需要注意每个 C 字符串的末尾的 '\0'。

C语言优化代码，用list存储从unsigned char * stream中根据\n分割字符存储，再将每个字符串按照逗号存储成数组

以下是一个可能的优化方案：

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

#define BUF_SIZE 1024

int main() {
    unsigned char *stream = "abc,def\nghi,jkl\nmno,pqr\n";
    size_t stream_len = strlen(stream);

    // 分配存储字符串的列表的空间
    char **string_list = (char **)malloc(stream_len * sizeof(char *));
    size_t string_list_len = 0;

    char *buf = (char *)malloc(BUF_SIZE * sizeof(char));
    size_t buf_len = 0;

    for (size_t i = 0; i < stream_len; i++) {
        if (stream[i] == ',' || stream[i] == '\n') {
            // 将新的字符串复制到列表中
            string_list[string_list_len] = (char *)malloc((buf_len + 1) * sizeof(char));
            strncpy(string_list[string_list_len], buf, buf_len);
            string_list[string_list_len][buf_len] = '\0';
            string_list_len++;

            // 重置缓冲区
            memset(buf, 0, buf_len);
            buf_len = 0;

            // 跳过逗号和换行符
            continue;
        }

        // 将字符添加到缓冲区中
        buf[buf_len++] = stream[i];

        // 如果缓冲区已满，则扩展缓冲区的大小
        if (buf_len == BUF_SIZE) {
            BUF_SIZE *= 2;
            buf = (char *)realloc(buf, BUF_SIZE * sizeof(char));
        }
    }

    // 将最后一个字符串复制到列表中
    string_list[string_list_len] = (char *)malloc((buf_len + 1) * sizeof(char));
    strncpy(string_list[string_list_len], buf, buf_len);
    string_list[string_list_len][buf_len] = '\0';
    string_list_len++;

    // 释放缓冲区
    free(buf);

    // 分配存储数组的空间
    char ***array_list = (char ***)malloc(string_list_len * sizeof(char **));
    size_t array_list_len = 0;

    for (size_t i = 0; i < string_list_len; i++) {
        char *string = string_list[i];

        if (*string == '\0') {
            // 忽略空字符串
            continue;
        }

        // 分配存储数组元素的空间
        char **array = (char **)malloc(BUF_SIZE * sizeof(char *));
        size_t array_len = 0;

        char *array_buf = (char *)malloc(BUF_SIZE * sizeof(char));
        size_t array_buf_len = 0;

        for (size_t j = 0; j < strlen(string); j++) {
            if (string[j] == ',') {
                // 将新的元素复制到数组中
                array[array_len] = (char *)malloc((array_buf_len + 1) * sizeof(char));
                strncpy(array[array_len], array_buf, array_buf_len);
                array[array_len][array_buf_len] = '\0';
                array_len++;

                // 重置缓冲区
                memset(array_buf, 0, array_buf_len);
                array_buf_len = 0;

                // 跳过逗号
                continue;
            }

            // 将字符添加到缓冲区中
            array_buf[array_buf_len++] = string[j];

            // 如果缓冲区已满，则扩展缓冲区的大小
            if (array_buf_len == BUF_SIZE) {
                BUF_SIZE *= 2;
                array_buf = (char *)realloc(array_buf, BUF_SIZE * sizeof(char));
            }
        }

        // 将最后一个元素复制到数组中
        array[array_len] = (char *)malloc((array_buf_len + 1) * sizeof(char));
        strncpy(array[array_len], array_buf, array_buf_len);
        array[array_len][array_buf_len] = '\0';
        array_len++;

        // 释放缓冲区
        free(array_buf);

        // 将数组添加到列表中
        array_list[array_list_len] = array;
        array_list_len++;
    }

    // 输出结果
    for (size_t i = 0; i < array_list_len; i++) {
        printf("array %lu: [", i);
        char **array = array_list[i];
        size_t array_len = strlen(array[0]);

        for (size_t j = 0; j < array_len; j++) {
            printf("%s", array[j]);

            if (j < array_len - 1) {
                printf(", ");
            }
        }

        printf("]\n");
    }

    // 释放存储字符串的列表的空间
    for (size_t i = 0; i < string_list_len; i++) {
        free(string_list[i]);
    }
    free(string_list);

    // 释放存储数组的空间
    for (size_t i = 0; i < array_list_len; i++) {
        char **array = array_list[i];
        size_t array_len = strlen(array[0]);

        for (size_t j = 0; j < array_len; j++) {
            free(array[j]);
        }

        free(array);
    }
    free(array_list);

    return 0;
}

该代码的主要思路是，首先将输入流中的所有字符串存储在一个列表中，然后将每个字符串按逗号分割，并将结果存储在一个数组中。可以看到，我们使用了动态内存分配来处理变长的输入流和字符串。

在处理输入流时，我们使用了一个缓冲区来存储当前正在读取的字符串。每当遇到逗号或换行符时，我们将缓冲区中的字符串复制到列表中，并重置缓冲区以准备读取下一个字符串。为了避免频繁的内存分配，我们使用了一个固定大小的缓冲区，并在需要时动态地扩展其大小。

在处理字符串时，我们使用类似的方法。我们使用一个缓冲区来存储当前正在读取的元素，并在遇到逗号时将其复制到数组中。为了避免频繁的内存分配，我们使用了一个固定大小的缓冲区，并在需要时动态地扩展其大小。

最后，我们输出存储的数组，并释放分配的内存。