用给定的分隔符分割字符串的函数

Question

我有一个名为 ft_split(char const *s, char c) 的函数，它应该接受字符串和分隔符 char c 并将 s 分成一堆更小的字符串。

我正在尝试解决它和我的方法是第 3 天或第 4 天：

1. 计算编号。字符串中的字符数，当时包括 1 个定界符（如果空格是定界符，那么如果一行中有 2 个或更多空格，则计算一个空格而不是更多。为什么？那个空格是用于添加 '\0' 的内存每个拆分字符串的结尾）

2. 它找到分隔符之间的字符大小 (k) -> malloc 内存 -> 从字符串复制到 malloc -> 从 malloc 复制到 malloc -> 重新开始。

但是...函数显示分段错误。调试器显示，在分配“大”内存后，它不会进入 while 循环，而是在退出函数后直接进入 big[y][z] = small[z]。

感谢任何提示。

#include "libft.h"
#include <stdlib.h>

int ft_count(char const *s, char c)
{
    int i;
    int j;

    i = 0;
    j = 0;
    while (s[i] != '\0')
    {
        i++;
        if (s[i] == c)
        {
            i++;
            while (s[i] == c)
            {
                i++;
                j++;
            }
        }
    }
    return (i - j);
}

char **ft_split(char const *s, char c)
{
    int i;
    int k;
    int y;
    int z;
    char *small;
    char **big;

    i = 0;
    y = 0;
    if (!(big = (char **)malloc((ft_count(s, c) + 1) * sizeof(char))))
        return (0);
    while (s[i] != '\0')
    {
        while (s[i] == c)
            i++;
        k = 0;
        while (s[i] != c)
        {
            i++;
            k++;
        }
        if (!(small = (char *)malloc(k * sizeof(char) + 1)))
            return (0);
        z = 0;
        while (z < k)
        {
            small[z] = s[i - k + z];
            z++;
        }
        small[k] = '\0';
        z = 0;
        while (z < k)
        {
            big[y][z] = small[z];
            z++;
        }
        y++;
        free(small);
    }
    big[y][i] = '\0';
    return (big);
}

int main()
{
    char a[] = "jestemzzbogiemzalfa";
    ft_split(a, 'z');
}

Answer 1

我没有得到代码所做的一切，但是：

你有一个char **big，它是一个指向字符的指针，所以大概应该指向一个char *的数组，然后指向字符串。看起来像这样：

[ big (char **) ] ->  [ big[0] (char *)  ][ big[1] (char *) ][ big[2] ... ]
                         |                   [
                         v                   v
                      [ big[0][0] (char) ]  ...
                      [ big[0][1] (char) ]
                      [ big[0][2] (char) ]
                      [ ...              ]

这里，当你调用big = malloc(N * sizeof(char *)) 时，你为中间指针分配空间，big[0] 到big[N-1]，水平数组中右上角的指针。它仍然没有将它们设置为任何东西，也没有为最终字符串保留空间（big[0][x] 等）

相反，您需要做类似的事情

big = malloc(N * sizeof(char *));
for (i = 0; i < N; i++) {
    big[i] = malloc(k);
}

单独为每个最终字符串，具有正确的大小等。或者只是一次性分配一个大区域，并将其拆分为最终字符串。

现在，在您的代码中，您似乎从未向big[y] 分配任何东西，因此它们可能是任何东西，这很可能解释了引用big[y][z] 时的段错误。如果您使用calloc()，那么您现在会发现big[y] 为NULL，而malloc() 可能是，也可能不是。

---

还有，这里：

    while (s[i] != '\0')
    {
        while (s[i] == c)
            i++;
        k = 0;
        while (s[i] != c)    /* here */
        {
            i++;
            k++;
        }

我想知道如果在while (s[i] != c) 到达字符串的结尾会发生什么，即如果s[i] 在那个时候是'\0'？循环应该可能会停止，但它看起来不像。

Answer 2

代码中存在多个问题：

• ft_count() 函数不正确：在测试分隔符之前增加 i，因此如果字符串以分隔符开头，则数字不正确。您应该计算从分隔符到非分隔符的转换次数：

int ft_count(char const *s, char c)
{
    char last;
    int i;
    int j;

    last = c;
    i = 0;
    j = 0;
    while (s[i] != '\0')
    {
        if (last == c && s[i] != c)
        {
            j++;
        }
        last = s[i];
        i++;
    }
    return j;
}

此外，ft_split() 函数也不正确：

• 为big 指针数组分配的内存量无效：您应该将元素数量乘以元素大小，这不是char，而是char *。
• 如果字符串以分隔符结尾，则在数组末尾添加一个空字符串。您应该在跳过分隔符后测试空字节。
• 您在扫描项目后的分隔符时不测试空终止符。
• 您没有将small 指针存储到big 指针数组中。不要将字符串复制到big[y][...]，而应该只设置big[y] = small 而不是free(small)。

这是修改后的版本：

char **ft_split(char const *s, char c)
{
    int i;
    int k;
    int y;
    int z;
    char *small;
    char **big;

    if (!(big = (char **)malloc((ft_count(s, c) + 1) * sizeof(*big))))
        return (0);
    i = 0;
    y = 0;
    while (42)  // aka 42 for ever :)
    {
        while (s[i] == c)
            i++;
        if (s[i] == '\0')
            break;
        k = 0;
        while (s[i + k] != '\0' && s[i + k] != c)
        {
            k++;
        }
        if (!(small = (char *)malloc((k + 1) * sizeof(char))))
            return (0);
        z = 0;
        while (z < k)
        {
            small[z] = s[i];
            z++;
            i++;
        }
        small[k] = '\0';
        big[y] = small;
        y++;
    }
    big[y] = NULL;
    return (big);
}

---

42 咆哮：

Ces conventions de codeage (la norminette) 这不是反产品！ Les boucles forsont plus lisibles et plus sûres que ces while, les casts sur les valeurs de retour de malloc()sont inutiles et confusantes, les parenthèses autour de l'argument de returnsont infantiles。