时间戳

首页 > 解决方案 > 用给定的分隔符分割字符串的函数

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

问题描述

我有一个名为的函数ft_split(char const *s, char c)，它应该接受字符串和分隔符字符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');
}

标签： cmultidimensional-arraymallocdelimiter

解决方案

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

你有一个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'那个时候？循环可能应该停止，但它看起来不像。

推荐阅读