无法正确分配内存，也无法在我的（ft_split）函数中释放它

Question

我正在尝试创建一个应该：

用malloc分配，并返回通过使用字符“ c”拆分“ s”获得的一系列字符串 作为定界线。阵列必须以空指针结尾。

我已将所有代码与下面的代码示例以及调试器给我的错误之一的断点。

现在遇到问题：

1. 当我输入字符串和末尾时，我添加了定界符，它给出了此错误为

字符串：

“是或不成为问题”

错误：

分割故障

2. 当我输入此字符串时，

：

“你好”

它将给出正确的答案，然后给出此错误

你好
那里
分割故障

3. 我只是无法弄清楚如何释放创建的内存分配，我认为我认为是正确的方法。

我的代码：

size_t  ft_strlen(const char *s)
{
    size_t  i;

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

char    *ft_strcpy(char *dest, const char *src)
{
        int     i;

        i = 0;
        while (src[i] != '\0')
        {
                dest[i] = src[i];
                i++;
        }
        dest[i] = '\0';
        return (dest);
}

char    *string_length(char const *str, char c, int i)
{
    int     j;
    char    *string;

    j = 0;
    // when i try the debugger with the first string in the main function it goes
    // directly to this line and break.
    string = (char *)malloc((ft_strlen(str)) * sizeof(*string));
    if(!string)
        return (NULL);
    while (str[i] == c)
        i++;
    while (str[i])
    {
        *string = str[i];
        if (str[i + 1] == c || str[i + 1] == '\0')
        {
            string++;
            j++;
            *string = '\0';
            return (string - j);
        }
        string++;
        j++;
        i++;
    }
    return (0);
}

int count_strings(char const *str, char c)
{
    int i;
    int count;
    int def;

    i = 0;
    count = 0;
    def = 1;
    while (str[i] == c)
        i++;
    while (str[i])
    {
        if (str[i] == c && def == 1)
        {
            i++;
            def = 0;
        }
        if (str[i] != c && def == 0)
        {
            count++;
            def = 1;
        }
        i++;
    }
    return (count);
}

int first_del(char const *str, char c, int i)
{
    while (str[i] == c)
        i++;
    return (i);

}
char    **ft_split(char const *s, char c)
{
    int     count;
    int     i;
    int     len;
    int     num_of_strings;
    char    **split;
    char    *string;
    char    **it;

    i = 0;
    count = 0;
    num_of_strings = count_strings(s, c);
    split = (char **)malloc((num_of_strings + 1) * sizeof(char *));
    if (!split)
        return (NULL);
    split[num_of_strings + 1] = NULL;
    while (i <= num_of_strings)
    {
        count = first_del(s, c, count);
        string = string_length(s, c, count);
        len = ft_strlen(string);
        split[i] = (char *)malloc(len + 1);
        ft_strcpy(split[i], string);
        count += len;
        i++;
        free(string);
        string = NULL;
    }
    return (split);
}
int main(void)
{
    char s[] = "   To    be    or    not    to    be    that     is   the question ";
    char **split_strings = ft_split(s, ' ');
    for (int i = 0; i < 10; i++)
        printf("%s\n", split_strings[i]);

    char s2[] = "Hello there";
    char **split_strings2 = ft_split(s2, ' ');
    for (int i = 0; i < 2; i++)
        printf("%s\n", split_strings2[i]);
} 

Answer 1

string = (char *)malloc((ft_strlen(str) + 1) * sizeof(*string));

split = (char **)malloc((num_of_strings + 2) * sizeof(char *));

为了释放主要函数中的内存分配：

int i = 0;
while (split_strings && split_strings[i])
{
    free (split_strings[i]);
    i++;
} 
free (split_strings); 

Xing的积分

Answer 2

首先，定义一个将给定字符串拆分为多个令牌的函数，由给定的分隔符隔开：

bool split(const char *str, const char sep, char **tokens, const size_t maxtokens, size_t *ntokens)
{
    *ntokens = 0;
    const char *start = str;
    const char *p = str;
    
    for (;;) {
        if (*ntokens >= maxtokens) return false;
        
        while (*p && *p == sep) ++p;
        if (!*p) return true;
        
        start = p;
        
        while (*p && *p != sep) ++p;
        
        size_t len = p - start;
        char *tmp = malloc(sizeof(char) * (len + 1));
        strncpy(tmp, start, len);
        tmp[len] = '\0';
        tokens[(*ntokens)++] = tmp;
        
        if (!*p) return true;
    }
    
    return true;
}

• str是要分配的字符串；
• sep是分隔符/分界符；
• 令牌是将保持令牌的数组；
• maxtokens是您的数组可以容纳的最大令牌（即其容量）；
• ntokens是str中的代币的实际编号。

返回：

• true如果字符串完全被标记化，
• false如果达到令牌限制的最大数量（maxtokens），并且字符串的结尾未达到。

---

然后，定义一个函数，该函数计算给定字符串中的令牌数：

size_t count_tokens(const char *str, const char sep)
{
    size_t counter = 0;
    for (const char *p = str; ; ) {
        while (*p && *p == sep) ++p;
        if (!*p) return counter;
        
        while (*p && *p != sep) ++p;
        ++counter;
        
        if (!*p) return counter;
    }
    return counter;
}

---

将两个函数放在一起：

int main(void)
{
    const char *str = "   To    be    or    not    to    be    that     is   the question ";
    
    const size_t maxtokens = count_tokens(str, ' ');
    size_t ntokens = 0;
    char *tokens[maxtokens+1]; // +1 for the last NULL entry.
    
    split(str, ' ', tokens, maxtokens, &ntokens);
    tokens[maxtokens] = NULL; // Last entry is NULL

    for (size_t i = 0; tokens[i]; ++i) {
        printf("%zu)\t%s\n", i+1, tokens[i]);
    }
}

输出：

1)  To
2)  be
3)  or
4)  not
5)  to
6)  be
7)  that
8)  is
9)  the
10) question

注释：

• 如果不允许使用＆lt; string.h＆gt; ，您可以用自己的版本替换strncpy（）。
• 不要忘记在使用令牌后立即释放使用malloc（）的内存。